diff --git a/libcudacxx/libcxx/test/libcxx/algorithms/half_positive.pass.cpp b/libcudacxx/libcxx/test/libcxx/algorithms/half_positive.pass.cpp
index 3d3d304d24f..5d594c12523 100644
--- a/libcudacxx/libcxx/test/libcxx/algorithms/half_positive.pass.cpp
+++ b/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;
 }
diff --git a/libcudacxx/libcxx/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp b/libcudacxx/libcxx/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
index 35bb2333d6c..202b17c14f3 100644
--- a/libcudacxx/libcxx/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
+++ b/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);
diff --git a/libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp b/libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp
index db2fc2fbf83..a83604930c0 100644
--- a/libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp
+++ b/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;
diff --git a/libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp b/libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
index 15c4b4ba98a..5020d93f361 100644
--- a/libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
+++ b/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() {
diff --git a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp b/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
index fc6a05b0d18..5f580ca909c 100644
--- a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
+++ b/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
diff --git a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp b/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
index 171774f6004..ecb4117935a 100644
--- a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
+++ b/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
diff --git a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp b/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
index 8061c706e65..4980f214fd8 100644
--- a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
+++ b/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
 
 }
 
diff --git a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp b/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
index 524a3491e80..55d9908209c 100644
--- a/libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
+++ b/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
diff --git a/libcudacxx/libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp b/libcudacxx/libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
index fdb534e5049..ebb09761f65 100644
--- a/libcudacxx/libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
+++ b/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>());
diff --git a/libcudacxx/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp b/libcudacxx/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp
index ac6f740bd02..1293b47943c 100644
--- a/libcudacxx/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp
+++ b/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;
diff --git a/libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp b/libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
index e7bb7a4e2f6..d75cfb2b34d 100644
--- a/libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
+++ b/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();
diff --git a/libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp b/libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
index 9c0f433506c..b4d73bb5c79 100644
--- a/libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
+++ b/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);
diff --git a/libcudacxx/libcxx/test/libcxx/libcpp_alignof.pass.cpp b/libcudacxx/libcxx/test/libcxx/libcpp_alignof.pass.cpp
index 5d16546e939..e5e062dad37 100644
--- a/libcudacxx/libcxx/test/libcxx/libcpp_alignof.pass.cpp
+++ b/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
diff --git a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
index b2bc48fee86..565ed6e856f 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
@@ -30,7 +30,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");
@@ -38,7 +37,6 @@ int main(int, char**)
     l1.erase(i);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
index 81cd872fb66..7e07779dd26 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
+++ b/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
diff --git a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
index cc22229d413..8a6faa6faa9 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
@@ -30,7 +30,6 @@ 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");
@@ -38,7 +37,6 @@ int main(int, char**)
     S::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
index e1b0591ac0e..e6c0a52c691 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
@@ -30,7 +30,6 @@ 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");
@@ -38,7 +37,6 @@ int main(int, char**)
     S::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
index e82b73c1b20..600ea7e431a 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
@@ -30,7 +30,6 @@ 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");
@@ -38,7 +37,6 @@ int main(int, char**)
     S::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
index 34d2ae14a16..1f59c68c5c5 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/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
diff --git a/libcudacxx/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp
index 3b96ab3125f..387c496654c 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp
+++ b/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;
 }
diff --git a/libcudacxx/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp b/libcudacxx/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp
index 3b798cef269..9ebaea1bd6f 100644
--- a/libcudacxx/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp
+++ b/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;
 }
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
index eec331bbf42..3247095d19d 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
@@ -89,7 +89,6 @@ struct MemFun03 {
 };
 
 
-#if TEST_STD_VER >= 2011
 
 //==============================================================================
 // MemFun11 - C++11 reference qualified test member functions.
@@ -122,7 +121,6 @@ struct MemFun11 {
     MemFun11& operator=(MemFun11 const&);
 };
 
-#endif // TEST_STD_VER >= 2011
 
 
 
@@ -166,10 +164,8 @@ struct TestCaseImp {
         runTestDispatchIf(NotRValue, tag, dref);
         runTestDispatchIf(NotRValue, tag, obj_ptr);
         runTestDispatchIf(NotRValue, tag, der_ptr);
-#if TEST_STD_VER >= 2011
         runTestDispatchIf(NotRValue, tag, rref);
         runTestDispatchIf(NotRValue, tag, drref);
-#endif
     }
 
     template <class QT, class Tp>
@@ -241,17 +237,14 @@ struct TestCaseImp {
 template <class Sig, int Arity, class CV>
 struct TestCase : public TestCaseImp<MemFun03, Sig, Arity, CV> {};
 
-#if TEST_STD_VER >= 2011
 template <class Sig, int Arity, class CV, bool RValue = false>
 struct TestCase11 : public TestCaseImp<MemFun11, Sig, Arity, CV, RValue, true> {};
-#endif
 
 template <class Tp>
 struct DerivedFromRefWrap : public std::reference_wrapper<Tp> {
   DerivedFromRefWrap(Tp& tp) : std::reference_wrapper<Tp>(tp) {}
 };
 
-#if TEST_STD_VER >= 2011
 void test_derived_from_ref_wrap() {
     int x = 42;
     std::reference_wrapper<int> r(x);
@@ -269,7 +262,6 @@ void test_derived_from_ref_wrap() {
     auto& ret3 = std::__invoke(get_fn, r2);
     assert(&ret3 == &x);
 }
-#endif
 
 int main(int, char**) {
     typedef void*& R;
@@ -307,7 +299,6 @@ int main(int, char**) {
     TestCase<R(A&, A&, A&, ...) volatile,           3, Q_Volatile>::run();
     TestCase<R(A&, A&, A&, ...) const volatile,     3, Q_CV>::run();
 
-#if TEST_STD_VER >= 2011
     TestCase11<R() &,                               0, Q_None>::run();
     TestCase11<R() const &,                         0, Q_Const>::run();
     TestCase11<R() volatile &,                      0, Q_Volatile>::run();
@@ -366,7 +357,6 @@ int main(int, char**) {
     TestCase11<R(A&&, A&&, A&&, ...)  const volatile &&,  3, Q_CV, /* RValue */ true>::run();
 
     test_derived_from_ref_wrap();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
index f2a1b4dc738..ba4ee13e1ee 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
@@ -84,10 +84,8 @@ struct TestCase {
             runTestDispatch<E>(M, dref2, &dref2.object.object);
             runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
             runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 2011
             runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
             runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
             runTestNoPropDispatch<E>(M, dref, &dref.object.object);
         }
         {
@@ -99,10 +97,8 @@ struct TestCase {
             runTestDispatch<E>(M, dref2, &dref2.object.object);
             runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
             runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 2011
             runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
             runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
             runTestNoPropDispatch<E>(M, dref,    &dref.object.object);
         }
         {
@@ -114,10 +110,8 @@ struct TestCase {
             runTestDispatch<E>(M, dref2, &dref2.object.object);
             runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
             runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 2011
             runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
             runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
             runTestNoPropDispatch<E>(M, dref,    &dref.object.object);
         }
         {
@@ -129,10 +123,8 @@ struct TestCase {
             runTestDispatch<E>(M, dref2, &dref2.object.object);
             runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
             runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 2011
             runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
             runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
             runTestNoPropDispatch<E>(M, dref,    &dref.object.object);
         }
     }
@@ -143,12 +135,10 @@ struct TestCase {
         runTest<Expect const&>         (M, C_<T const&>(obj),          expect);
         runTest<Expect volatile&>      (M, C_<T volatile&>(obj),       expect);
         runTest<Expect const volatile&>(M, C_<T const volatile&>(obj), expect);
-#if TEST_STD_VER >= 2011
         runTest<Expect&&>               (M, C_<T&&>(obj),                expect);
         runTest<Expect const&&>         (M, C_<T const&&>(obj),          expect);
         runTest<Expect volatile&&>      (M, C_<T volatile&&>(obj),       expect);
         runTest<Expect const volatile&&>(M, C_<T const volatile&&>(obj), expect);
-#endif
     }
 
     template <class Expect, class Fn, class T>
@@ -165,12 +155,10 @@ struct TestCase {
         runTest<Expect&>(M, C_<T const&>(obj),          expect);
         runTest<Expect&>(M, C_<T volatile&>(obj),       expect);
         runTest<Expect&>(M, C_<T const volatile&>(obj), expect);
-#if TEST_STD_VER >= 2011
         runTest<Expect&>(M, C_<T&&>(obj),                expect);
         runTest<Expect&>(M, C_<T const&&>(obj),          expect);
         runTest<Expect&>(M, C_<T volatile&&>(obj),       expect);
         runTest<Expect&>(M, C_<T const volatile&&>(obj), expect);
-#endif
     }
 
     template <class Expect, class Fn, class T>
@@ -183,11 +171,7 @@ struct TestCase {
     }
 
     template <class Expect, class Fn, class T>
-#if TEST_STD_VER >= 2011
     void runTest(Fn M, T&& obj, ObjectType* expect) {
-#else
-    void runTest(Fn M, T& obj, ObjectType* expect ) {
-#endif
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(M, std::forward<T>(obj))), Expect
@@ -195,7 +179,6 @@ struct TestCase {
             Expect e = std::__invoke(M, std::forward<T>(obj));
             assert(&e == expect);
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(M, std::forward<T>(obj))), Expect
@@ -203,7 +186,6 @@ struct TestCase {
             Expect e = std::__invoke(M, std::forward<T>(obj));
             assert(&e == expect);
         }
-#endif
     }
 };
 
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
index fe319f743e2..81e32f5c68d 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
@@ -115,7 +115,6 @@ struct Functor03 {
 };
 
 
-#if TEST_STD_VER >= 2011
 
 //==============================================================================
 // freeFunction11 - A C++11 free function.
@@ -155,7 +154,6 @@ struct Functor11 {
     Functor11& operator=(Functor11 const&);
 };
 
-#endif // TEST_STD_VER >= 2011
 
 
 //==============================================================================
@@ -207,19 +205,15 @@ struct TestCaseFreeFunction {
 //==============================================================================
 //                          runTest Helpers
 //==============================================================================
-#if TEST_STD_VER >= 2011
 template <class Sig, int Arity, class ArgCaster>
 void runFunctionTestCase11() {
     TestCaseFreeFunction<Sig, freeFunction11, Arity, ArgCaster>();
 }
-#endif
 
 template <class Sig, int Arity, class ArgCaster>
 void runFunctionTestCase() {
     TestCaseFreeFunction<Sig, freeFunction03, Arity, ArgCaster>();
-#if TEST_STD_VER >= 2011
     runFunctionTestCase11<Sig, Arity, ArgCaster>();
-#endif
 }
 
 template <class Sig, int Arity, class ObjCaster, class ArgCaster>
@@ -232,13 +226,11 @@ void runFunctorTestCase() {
     TestCaseFunctorImp<Functor03, Sig, Arity, ObjCaster>::run();
 }
 
-#if TEST_STD_VER >= 2011
 // runTestCase - Run a test case for C++11 class functor types
 template <class Sig, int Arity, class ObjCaster, class ArgCaster = LValueCaster>
 void runFunctorTestCase11() {
     TestCaseFunctorImp<Functor11, Sig, Arity, ObjCaster, ArgCaster>::run();
 }
-#endif
 
 // runTestCase - Run a test case for both function and functor types.
 template <class Sig, int Arity, class ArgCaster>
@@ -265,10 +257,8 @@ int main(int, char**) {
     runFunctionTestCase<R(A&, A&, ...),                 2, LValueCaster      >();
     runFunctionTestCase<R(A&, A&, A&, ...),             3, LValueCaster      >();
 
-#if TEST_STD_VER >= 2011
     runFunctionTestCase11<R(A&&),                       1, MoveCaster        >();
     runFunctionTestCase11<R(A&&, ...),                  1, MoveCaster        >();
-#endif
 
     runFunctorTestCase<R(),                             0, LValueCaster      >();
     runFunctorTestCase<R() const,                       0, ConstCaster       >();
@@ -302,7 +292,6 @@ int main(int, char**) {
     runFunctorTestCase<R(CA&, CA&, CA&) const volatile, 3, CVCaster,       CC>();
     }
 
-#if TEST_STD_VER >= 2011
     runFunctorTestCase11<R() &,                    0, LValueCaster          >();
     runFunctorTestCase11<R() const &,              0, ConstCaster           >();
     runFunctorTestCase11<R() volatile &,           0, VolatileCaster        >();
@@ -322,7 +311,6 @@ int main(int, char**) {
     runFunctorTestCase11<R(A&&) volatile &&,       1, MoveVolatileCaster, MC>();
     runFunctorTestCase11<R(A&&) const volatile &&, 1, MoveCVCaster,       MC>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
index 47d9f2a8d01..2307a1adbb6 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
@@ -23,24 +23,20 @@ struct Type
 {
     Array<char, 1>::type& f1();
     Array<char, 2>::type& f2() const;
-#if TEST_STD_VER >= 2011
     Array<char, 1>::type& g1()        &;
     Array<char, 2>::type& g2() const  &;
     Array<char, 3>::type& g3()       &&;
     Array<char, 4>::type& g4() const &&;
-#endif
 };
 
 int main(int, char**)
 {
     static_assert(sizeof(std::__invoke(&Type::f1, std::declval<Type        >())) == 1, "");
     static_assert(sizeof(std::__invoke(&Type::f2, std::declval<Type const  >())) == 2, "");
-#if TEST_STD_VER >= 2011
     static_assert(sizeof(std::__invoke(&Type::g1, std::declval<Type       &>())) == 1, "");
     static_assert(sizeof(std::__invoke(&Type::g2, std::declval<Type const &>())) == 2, "");
     static_assert(sizeof(std::__invoke(&Type::g3, std::declval<Type      &&>())) == 3, "");
     static_assert(sizeof(std::__invoke(&Type::g4, std::declval<Type const&&>())) == 4, "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
index 8d74d887086..85c5b468800 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
+++ b/libcudacxx/libcxx/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
@@ -52,13 +52,9 @@ struct Caster {
     struct apply {
         typedef typename std::remove_reference<T>::type RawType;
         typedef typename QualTag::template apply<RawType>::type CVType;
-#if TEST_STD_VER >= 2011
         typedef typename std::conditional<RValue,
             CVType&&, CVType&
         >::type type;
-#else
-        typedef CVType& type;
-#endif
     };
 
     template <class T>
@@ -165,12 +161,6 @@ struct DerefPropType {
     template <class Up>
     explicit DerefPropType(Up const& val) : object(val) {}
 
-#if TEST_STD_VER < 2011
-    To& operator*() { return object; }
-    To const& operator*() const { return object; }
-    To volatile& operator*() volatile  { return object; }
-    To const volatile& operator*() const volatile { return object; }
-#else
     To& operator*() & { return object; }
     To const& operator*() const & { return object; }
     To volatile& operator*() volatile  & { return object; }
@@ -179,7 +169,6 @@ struct DerefPropType {
     To const&& operator*() const && { return static_cast<To const&&>(object); }
     To volatile&& operator*() volatile  && { return static_cast<To volatile&&>(object); }
     To const volatile&& operator*() const volatile && { return static_cast<To const volatile&&>(object); }
-#endif
 };
 
 //==============================================================================
@@ -282,7 +271,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object)))
@@ -291,7 +279,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 
     template <class MethodPtr, class ObjectT>
@@ -304,7 +291,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0)))
@@ -313,7 +299,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 
     template <class MethodPtr, class ObjectT>
@@ -326,7 +311,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
@@ -335,7 +319,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 
     template <class MethodPtr, class ObjectT>
@@ -348,7 +331,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
@@ -357,7 +339,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 
     //==========================================================================
@@ -373,7 +354,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object)))
@@ -382,7 +362,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 
     template <class ObjectT>
@@ -395,7 +374,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object), arg_cast(a0)))
@@ -404,7 +382,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 
     template <class ObjectT>
@@ -417,7 +394,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1)))
@@ -426,7 +402,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 
     template <class ObjectT>
@@ -439,7 +414,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 2011
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
@@ -448,7 +422,6 @@ struct BasicTest {
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
             assert(ID::checkCalled(ret));
         }
-#endif
     }
 };
 
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp b/libcudacxx/libcxx/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
index dd5ba1e0fa3..594bf563ffd 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
@@ -15,22 +15,15 @@
 
 #include "test_macros.h"
 
-// libc++ doesn't offer std::pointer_safety in C++03 under the new ABI
-#if TEST_STD_VER < 2011 && defined(_LIBCUDACXX_ABI_POINTER_SAFETY_ENUM_TYPE)
-#define TEST_IS_UNSUPPORTED
-#endif
 
-#ifndef TEST_IS_UNSUPPORTED
 void test_pr26961() {
   std::pointer_safety d;
   d = std::get_pointer_safety();
   assert(d == std::get_pointer_safety());
 }
-#endif
 
 int main(int, char**)
 {
-#ifndef TEST_IS_UNSUPPORTED
   {
     // Test that std::pointer_safety is still offered in C++03 under the old ABI.
     std::pointer_safety r = std::get_pointer_safety();
@@ -41,7 +34,6 @@ int main(int, char**)
   {
     test_pr26961();
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp b/libcudacxx/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp
index 80c4a3bdbc2..eaef662101c 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp
@@ -33,10 +33,8 @@ static_assert(( std::__libcpp_is_referenceable<Foo>::value), "");
 static_assert(( std::__libcpp_is_referenceable<const Foo>::value), "");
 static_assert(( std::__libcpp_is_referenceable<Foo &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<const Foo &>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<Foo &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<const Foo &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<int   __attribute__((__vector_size__( 8)))>::value), "");
 static_assert(( std::__libcpp_is_referenceable<const int   __attribute__((__vector_size__( 8)))>::value), "");
@@ -45,149 +43,117 @@ static_assert(( std::__libcpp_is_referenceable<const float __attribute__((__vect
 
 // Functions without cv-qualifiers are referenceable
 static_assert(( std::__libcpp_is_referenceable<void ()>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void () const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void () &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void () const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void () &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void () const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (int)>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void (int) const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int) &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int) const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int) &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (int, float)>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void (int, float) const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float) &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float) const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float) &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (int, float, Foo &)>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &) const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &) &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &) const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &) &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (...)>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void (...) const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (...) &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (...) const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (...) &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (...) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (int, ...)>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void (int, ...) const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, ...) &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, ...) const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, ...) &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, ...) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (int, float, ...)>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void (int, float, ...) const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, ...) &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, ...) const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, ...) &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, ...) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (int, float, Foo &, ...)>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &, ...) const>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &, ...) &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &, ...) const &>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &, ...) &&>::value), "");
 static_assert((!std::__libcpp_is_referenceable<void (int, float, Foo &, ...) const &&>::value), "");
-#endif
 
 // member functions with or without cv-qualifiers are referenceable
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)()>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)() const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)() &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)() const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)() &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)() const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int)>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int) const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int) &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int) const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int) &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float)>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float) const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float) &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float) const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float) &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &)>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &) const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &) &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &) const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &) &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(...)>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(...) const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(...) &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(...) const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(...) &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(...) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, ...)>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, ...) const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, ...) &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, ...) const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, ...) &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, ...) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...)>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) const &&>::value), "");
-#endif
 
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &, ...)>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &, ...) const>::value), "");
-#if TEST_STD_VER >= 2011
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &, ...) &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &, ...) &&>::value), "");
 static_assert(( std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &&>::value), "");
-#endif
 
 int main(int, char**) {
   return 0;
diff --git a/libcudacxx/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp b/libcudacxx/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
index 3b9558aa928..c4732650447 100644
--- a/libcudacxx/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
+++ b/libcudacxx/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
@@ -30,12 +30,9 @@ template <class T>
 struct HasTrivialABI : std::integral_constant<bool,
     std::is_trivially_destructible<T>::value
     && (!std::is_copy_constructible<T>::value || std::is_trivially_copy_constructible<T>::value)
-#if TEST_STD_VER >= 2011
-   && (!std::is_move_constructible<T>::value || std::is_trivially_move_constructible<T>::value)
-#endif
+    && (!std::is_move_constructible<T>::value || std::is_trivially_move_constructible<T>::value)
 > {};
 
-#if TEST_STD_VER >= 2011
 struct NonTrivialDtor {
     NonTrivialDtor(NonTrivialDtor const&) = default;
     ~NonTrivialDtor();
@@ -71,7 +68,6 @@ struct Trivial {
     Trivial(Trivial const&) = default;
 };
 static_assert(HasTrivialABI<Trivial>::value, "");
-#endif
 
 
 void test_trivial()
@@ -81,7 +77,6 @@ void test_trivial()
         static_assert(std::is_copy_constructible<P>::value, "");
         static_assert(HasTrivialABI<P>::value, "");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<int, short> P;
         static_assert(std::is_move_constructible<P>::value, "");
@@ -136,7 +131,6 @@ void test_trivial()
         static_assert(std::is_trivially_move_constructible<P>::value, "");
         static_assert(HasTrivialABI<P>::value, "");
     }
-#endif
 }
 
 void test_layout() {
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
index fdf9d21d78c..6abced544ce 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -36,7 +36,6 @@ test()
         assert(ia[i] == ib[i]);
 }
 
-#if TEST_STD_VER >= 2011
 template <class InIter, class OutIter>
 void
 test1()
@@ -52,7 +51,6 @@ test1()
     for (unsigned i = 0; i < N; ++i)
         assert(*ib[i] == static_cast<int>(i));
 }
-#endif
 
 int main(int, char**)
 {
@@ -91,7 +89,6 @@ int main(int, char**)
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
 
-#if TEST_STD_VER >= 2011
     test1<cpp17_input_iterator<std::unique_ptr<int>*>, cpp17_output_iterator<std::unique_ptr<int>*> >();
     test1<cpp17_input_iterator<std::unique_ptr<int>*>, cpp17_input_iterator<std::unique_ptr<int>*> >();
     test1<cpp17_input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
@@ -126,7 +123,6 @@ int main(int, char**)
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
index 24557d263aa..04ef6d4b341 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -36,7 +36,6 @@ test()
         assert(ia[i] == ib[i]);
 }
 
-#if TEST_STD_VER >= 2011
 template <class InIter, class OutIter>
 void
 test1()
@@ -52,7 +51,6 @@ test1()
     for (unsigned i = 0; i < N; ++i)
         assert(*ib[i] == static_cast<int>(i));
 }
-#endif
 
 int main(int, char**)
 {
@@ -68,7 +66,6 @@ int main(int, char**)
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
 
-#if TEST_STD_VER >= 2011
     test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
@@ -80,7 +77,6 @@ int main(int, char**)
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
index 8696065473e..bcb67d601d7 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
@@ -281,7 +281,6 @@ test()
     }
 }
 
-#if TEST_STD_VER >= 2011
 
 struct is_null
 {
@@ -299,7 +298,6 @@ test1()
     assert(r == Iter(array+size));
 }
 
-#endif  // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -307,9 +305,7 @@ int main(int, char**)
     test<random_access_iterator<std::pair<int,int>*> >();
     test<std::pair<int,int>*>();
 
-#if TEST_STD_VER >= 2011
     test1<bidirectional_iterator<std::unique_ptr<int>*> >();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
index e9649f3f098..53b1b639249 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
@@ -49,7 +49,6 @@ test()
     assert(ia[5] == 4);
 }
 
-#if TEST_STD_VER >= 2011
 template <class Iter>
 void
 test1()
@@ -71,7 +70,6 @@ test1()
     assert(*ia[4] == 3);
     assert(*ia[5] == 4);
 }
-#endif // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -80,12 +78,10 @@ int main(int, char**)
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#if TEST_STD_VER >= 2011
     test1<forward_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
-#endif // TEST_STD_VER >= 2011
 
 #if TEST_STD_VER > 2017
     static_assert(test_constexpr());
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
index 5c078660928..a6efd7b8ba9 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
@@ -56,7 +56,6 @@ test()
     assert(cp.count() == sa);
 }
 
-#if TEST_STD_VER >= 2011
 struct pred
 {
     bool operator()(const std::unique_ptr<int>& i) {return *i == 2;}
@@ -86,7 +85,6 @@ test1()
     assert(*ia[4] == 3);
     assert(*ia[5] == 4);
 }
-#endif // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -95,12 +93,10 @@ int main(int, char**)
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#if TEST_STD_VER >= 2011
     test1<forward_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
-#endif // TEST_STD_VER >= 2011
 
 #if TEST_STD_VER > 2017
     static_assert(test_constexpr());
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
index 0b0dcc9e57d..a1b78cafccf 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
@@ -211,7 +211,6 @@ test()
     assert(ig[5] == 2);
 }
 
-#if TEST_STD_VER >= 2011
 
 template <class Iter>
 void
@@ -417,7 +416,6 @@ test1()
     assert(*ig[5] == 2);
 }
 
-#endif  // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -426,14 +424,12 @@ int main(int, char**)
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#if TEST_STD_VER >= 2011
 
     test1<forward_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
index 589f7aa1aea..e37b6e465fd 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
@@ -36,7 +36,6 @@ test()
     assert(j[2] == 3);
 }
 
-#if TEST_STD_VER >= 2011
 template<class Iter1, class Iter2>
 void
 test1()
@@ -56,7 +55,6 @@ test1()
     assert(*j[1] == 2);
     assert(*j[2] == 3);
 }
-#endif // TEST_STD_VER >= 2011
 
 void test2()
 {
@@ -142,7 +140,6 @@ int main(int, char**)
     test<int*, random_access_iterator<int*> >();
     test<int*, int*>();
 
-#if TEST_STD_VER >= 2011
     test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
@@ -162,7 +159,6 @@ int main(int, char**)
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
-#endif // TEST_STD_VER >= 2011
 
 #if TEST_STD_VER > 2017
     static_assert(test_swap_constexpr());
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
index 32ee217cc15..c5382bfd977 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
@@ -95,7 +95,6 @@ test()
     assert(ii[2] == 2);
 }
 
-#if TEST_STD_VER >= 2011
 
 struct do_nothing
 {
@@ -179,7 +178,6 @@ test1()
     assert(*ii[1] == 1);
     assert(*ii[2] == 2);
 }
-#endif // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -188,12 +186,10 @@ int main(int, char**)
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#if TEST_STD_VER >= 2011
     test1<forward_iterator<Ptr*> >();
     test1<bidirectional_iterator<Ptr*> >();
     test1<random_access_iterator<Ptr*> >();
     test1<Ptr*>();
-#endif
 
 #if TEST_STD_VER > 2017
     static_assert(test_constexpr());
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
index 834c06c96be..aa8b4b9bdde 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
@@ -121,7 +121,6 @@ test()
     assert(count_equal::count == si-1);
 }
 
-#if TEST_STD_VER >= 2011
 
 struct do_nothing
 {
@@ -221,7 +220,6 @@ test1()
     assert(*ii[2] == 2);
     assert(count_equal::count == si-1);
 }
-#endif // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -230,12 +228,10 @@ int main(int, char**)
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#if TEST_STD_VER >= 2011
     test1<forward_iterator<Ptr*> >();
     test1<bidirectional_iterator<Ptr*> >();
     test1<random_access_iterator<Ptr*> >();
     test1<Ptr*>();
-#endif
 
 #if TEST_STD_VER > 2017
     static_assert(test_constexpr());
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
index e1651bce646..162b22c1c00 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
@@ -91,7 +91,6 @@ int main(int, char**)
     test(10000);
     test(100000);
 
-#if TEST_STD_VER >= 2011
     {
     const int N = 1000;
     std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
@@ -102,7 +101,6 @@ int main(int, char**)
     assert(std::is_heap(ia, ia+N, indirect_less()));
     delete [] ia;
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
index e64079fe8c1..971239af872 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
@@ -63,7 +63,6 @@ int main(int, char**)
 {
     test(1000);
 
-#if TEST_STD_VER >= 2011
     {
     const int N = 1000;
     std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
@@ -78,7 +77,6 @@ int main(int, char**)
     }
     delete [] ia;
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
index 9f6420c7d70..31c3c5d38b7 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
@@ -59,7 +59,6 @@ int main(int, char**)
 {
     test(1000);
 
-#if TEST_STD_VER >= 2011
     {
     const int N = 1000;
     std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
@@ -73,7 +72,6 @@ int main(int, char**)
     }
     delete [] ia;
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
index 5b2f033a319..8dcc3341417 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
@@ -58,7 +58,6 @@ int main(int, char**)
     test(10);
     test(1000);
 
-#if TEST_STD_VER >= 2011
     {
     const int N = 1000;
     std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
@@ -70,7 +69,6 @@ int main(int, char**)
     assert(std::is_sorted(ia, ia+N, indirect_less()));
     delete [] ia;
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
index e15a213b9fe..e7d8b414b97 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
@@ -21,7 +21,6 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#if TEST_STD_VER >= 2011
 struct S {
     S() : i_(0) {}
     S(int i) : i_(i) {}
@@ -41,7 +40,6 @@ struct S {
 
     int i_;
     };
-#endif
 
 std::mt19937 randomness;
 
@@ -103,11 +101,9 @@ int main(int, char**)
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#if TEST_STD_VER >= 2011
     test<bidirectional_iterator<S*> >();
     test<random_access_iterator<S*> >();
     test<S*>();
-#endif  // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
index ddfae7a9645..3c5b0cab1d9 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -21,7 +21,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
 #include <memory>
 
 struct indirect_less
@@ -53,7 +52,6 @@ struct S {
     };
 
 
-#endif  // TEST_STD_VER >= 2011
 
 #include "test_iterators.h"
 #include "counting_predicates.h"
@@ -141,7 +139,6 @@ int main(int, char**)
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#if TEST_STD_VER >= 2011
     test<bidirectional_iterator<S*> >();
     test<random_access_iterator<S*> >();
     test<S*>();
@@ -164,7 +161,6 @@ int main(int, char**)
     }
     delete [] ia;
     }
-#endif  // TEST_STD_VER >= 2011
 
     test_PR31166();
 
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
index c18f082cfb9..69ad4150974 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
@@ -76,7 +76,6 @@ int main(int, char**)
     test(1000);
     test(1009);
 
-#if TEST_STD_VER >= 2011
     {
     std::vector<std::unique_ptr<int> > v(1000);
     for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
@@ -84,7 +83,6 @@ int main(int, char**)
     std::nth_element(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less());
     assert(static_cast<std::size_t>(*v[v.size()/2]) == v.size()/2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
index 574227fd11a..5640483127b 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
@@ -82,7 +82,6 @@ int main(int, char**)
     test_larger_sorts(1009);
     }
 
-#if TEST_STD_VER >= 2011
     {
     std::vector<std::unique_ptr<int> > v(1000);
     for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
@@ -91,7 +90,6 @@ int main(int, char**)
     for (int i = 0; static_cast<std::size_t>(i) < v.size()/2; ++i)
         assert(*v[i] == i);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
index 6390c85e7b9..04f1eddb2bd 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
@@ -41,7 +41,6 @@ int main(int, char**)
     assert(std::is_sorted(v.begin(), v.end()));
     }
 
-#if TEST_STD_VER >= 2011
     {
     std::vector<std::unique_ptr<int> > v(1000);
     for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
@@ -52,7 +51,6 @@ int main(int, char**)
     assert(*v[1] == 1);
     assert(*v[2] == 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
index 75ceb40ad20..7328d29f505 100644
--- a/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
@@ -70,7 +70,6 @@ int main(int, char**)
 {
     test();
 
-#if TEST_STD_VER >= 2011
     {
     std::vector<std::unique_ptr<int> > v(1000);
     for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
@@ -81,7 +80,6 @@ int main(int, char**)
     assert(*v[1] == 1);
     assert(*v[2] == 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/Emplaceable.h b/libcudacxx/libcxx/test/std/containers/Emplaceable.h
index 9e4a1fc8d5a..ad4ffef3a81 100644
--- a/libcudacxx/libcxx/test/std/containers/Emplaceable.h
+++ b/libcudacxx/libcxx/test/std/containers/Emplaceable.h
@@ -12,8 +12,6 @@
 #include <functional>
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
-
 class Emplaceable
 {
     Emplaceable(const Emplaceable&);
@@ -53,5 +51,4 @@ struct hash<Emplaceable>
 
 }
 
-#endif  // TEST_STD_VER >= 2011
 #endif  // EMPLACEABLE_H
diff --git a/libcudacxx/libcxx/test/std/containers/associative/iterator_types.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/iterator_types.pass.cpp
index 6caa256fed4..5d1b1dcd729 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/iterator_types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/iterator_types.pass.cpp
@@ -62,14 +62,12 @@ int main(int, char**) {
     typedef std::map<int, int, std::less<int>, Alloc> Map;
     testMap<Map, ValueTp, ValueTp*, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::pair<const int, int> ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::map<int, int, std::less<int>, Alloc> Map;
     testMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
   }
-#endif
   {
     typedef std::multimap<int, int> Map;
     typedef std::pair<const int, int> ValueTp;
@@ -81,14 +79,12 @@ int main(int, char**) {
     typedef std::multimap<int, int, std::less<int>, Alloc> Map;
     testMap<Map, ValueTp, ValueTp*, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::pair<const int, int> ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::multimap<int, int, std::less<int>, Alloc> Map;
     testMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
   }
-#endif
   {
     typedef int ValueTp;
     typedef std::set<ValueTp> Set;
@@ -100,14 +96,12 @@ int main(int, char**) {
     typedef std::set<ValueTp, std::less<ValueTp>, Alloc> Set;
     testSet<Set, ValueTp, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef int ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::set<ValueTp, std::less<ValueTp>, Alloc> Set;
     testSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
-#endif
   {
     typedef int ValueTp;
     typedef std::multiset<ValueTp> Set;
@@ -119,14 +113,12 @@ int main(int, char**) {
     typedef std::multiset<ValueTp, std::less<ValueTp>, Alloc> Set;
     testSet<Set, ValueTp, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef int ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::multiset<ValueTp, std::less<ValueTp>, Alloc> Set;
     testSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/at.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/at.pass.cpp
index 953f7a87838..6dde7041ef6 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/at.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/at.pass.cpp
@@ -90,7 +90,6 @@ int main(int, char**)
         assert(m.at(8) == 8.5);
         assert(m.size() == 7);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -159,7 +158,6 @@ int main(int, char**)
         assert(m.at(8) == 8.5);
         assert(m.size() == 7);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/empty.pass.cpp
index e0212e2f6ac..8160be4dc38 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/empty.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -39,7 +38,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/index_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/index_key.pass.cpp
index 57a4dc3f765..25c03d1d12b 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/index_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/index_key.pass.cpp
@@ -19,9 +19,7 @@
 #include "count_new.h"
 #include "min_allocator.h"
 #include "private_constructor.h"
-#if TEST_STD_VER >= 2011
 #include "container_test_types.h"
-#endif
 
 int main(int, char**)
 {
@@ -50,7 +48,6 @@ int main(int, char**)
     assert(m[6] == 6.5);
     assert(m.size() == 8);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -110,7 +107,6 @@ int main(int, char**)
             }
         }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::pair<const int, double> V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp
index a68fbc21c3e..3fcb3b6bc05 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp
@@ -120,7 +120,6 @@ int main(int, char**)
             assert(i->second == 1);
         }
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -207,7 +206,6 @@ int main(int, char**)
             assert(i->second == 1);
         }
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::map<int, double> C;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/size.pass.cpp
index 63b2f7daaa4..a8229fec3d6 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.access/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.access/size.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -55,7 +54,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/alloc.pass.cpp
index 26f26670f6b..ce6bd861dac 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/alloc.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
@@ -46,7 +45,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp
index 89a35dda201..3881767615d 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare.pass.cpp
@@ -28,7 +28,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef test_less<int> C;
     const std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
@@ -36,7 +35,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
index 08e953ab20e..0cc125b3baf 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
@@ -31,7 +31,6 @@ int main(int, char**)
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef test_less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
@@ -50,7 +49,6 @@ int main(int, char**)
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A{});
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp
index 3a0ed9a0de6..30b7d19583d 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp
@@ -57,7 +57,6 @@ int main(int, char**)
         assert(*std::next(mo.begin()) == V(2, 1));
         assert(*std::next(mo.begin(), 2) == V(3, 1));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -126,7 +125,6 @@ int main(int, char**)
         assert(*std::next(mo.begin()) == V(2, 1));
         assert(*std::next(mo.begin(), 2) == V(3, 1));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
index 590665b5081..fa5e6f60314 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
@@ -57,7 +57,6 @@ int main(int, char**)
     assert(*std::next(mo.begin()) == V(2, 1));
     assert(*std::next(mo.begin(), 2) == V(3, 1));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -126,7 +125,6 @@ int main(int, char**)
     assert(*std::next(mo.begin()) == V(2, 1));
     assert(*std::next(mo.begin(), 2) == V(3, 1));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
index 867a768b02c..99c8018473c 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
@@ -27,7 +27,6 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
 std::vector<int> ca_allocs;
 std::vector<int> ca_deallocs;
 
@@ -115,7 +114,6 @@ bool balanced_allocs() {
 
     return true;
 }
-#endif
 
 int main(int, char**)
 {
@@ -204,7 +202,6 @@ int main(int, char**)
         assert(*std::next(mo.begin()) == V(2, 1));
         assert(*std::next(mo.begin(), 2) == V(3, 1));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -345,7 +342,6 @@ int main(int, char**)
         assert(*std::next(mo.begin(), 2) == V(3, 1));
     }
     assert(balanced_allocs());
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/default.pass.cpp
index abc9107b248..c49d53a846a 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/default.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
     std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> m;
     assert(m.empty());
@@ -50,7 +49,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
index 0be437c275a..e91e80926c6 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
@@ -42,7 +42,6 @@ int main(int, char**)
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -64,7 +63,6 @@ int main(int, char**)
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
index 348efbea6a3..43ead9612be 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     assert(*std::next(m.begin()) == V(2, 1));
     assert(*std::next(m.begin(), 2) == V(3, 1));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -70,7 +69,6 @@ int main(int, char**)
     assert(*std::next(m.begin()) == V(2, 1));
     assert(*std::next(m.begin(), 2) == V(3, 1));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
index bed6c9093c1..ebd70fadfe3 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -61,7 +60,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
index c34dcd0e3aa..5ffd1aa3b04 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
@@ -134,7 +134,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -241,7 +240,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
index a9cf073048c..eb4d07ac277 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
@@ -86,7 +86,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -153,7 +152,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
index f427a4029d9..67ec0a11268 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
@@ -145,7 +145,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(s == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -271,7 +270,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(s == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
index 392212b53ee..8502eabf5aa 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
@@ -62,12 +62,10 @@ void do_insert_cv_test()
 int main(int, char**)
 {
     do_insert_cv_test<std::map<int, double> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         do_insert_cv_test<M>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
index 4e34b234d82..b5c71e4c211 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
@@ -58,12 +58,10 @@ void do_insert_iter_cv_test()
 int main(int, char**)
 {
     do_insert_iter_cv_test<std::map<int, double> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         do_insert_iter_cv_test<M>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
index 7f93d42d338..290031b4c3e 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(next(m.begin(), 2)->first == 3);
         assert(next(m.begin(), 2)->second == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -73,7 +72,6 @@ int main(int, char**)
         assert(next(m.begin(), 2)->first == 3);
         assert(next(m.begin(), 2)->second == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/count.pass.cpp
index 980e0ec8eb9..c30bf5422e8 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/count.pass.cpp
@@ -59,7 +59,6 @@ int main(int, char**)
         assert(r == 0);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
@@ -97,7 +96,6 @@ int main(int, char**)
         assert(r == 0);
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::pair<const int, double> V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/equal_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
index 46a49e7f289..e49fd7d3bc0 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
@@ -159,7 +159,6 @@ int main(int, char**)
         assert(r.second == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
@@ -296,7 +295,6 @@ int main(int, char**)
         assert(r.second == next(m.begin(), 8));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::pair<const int, double> V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/find.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/find.pass.cpp
index 108198d62f3..47de426d7f5 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/find.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/find.pass.cpp
@@ -93,7 +93,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
@@ -164,7 +163,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::pair<const int, double> V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
index dd4127f4863..e761c02b147 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
@@ -125,7 +125,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
@@ -228,7 +227,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::pair<const int, double> V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
index 5fac58c0280..96ee299adbf 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
@@ -124,7 +124,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
@@ -227,7 +226,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::pair<const int, double> V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.special/member_swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.special/member_swap.pass.cpp
index ac4bd70a433..46448a6f774 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.special/member_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.special/member_swap.pass.cpp
@@ -96,7 +96,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
     {
@@ -172,7 +171,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
index dbfde23e960..639f9268e57 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
@@ -168,7 +168,6 @@ int main(int, char**)
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
     {
@@ -278,7 +277,6 @@ int main(int, char**)
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/map/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/map/types.pass.cpp
index a0904431b7b..4b9011b8019 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/map/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/map/types.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
@@ -66,7 +65,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/empty.pass.cpp
index 22c7a92685f..2a1fb77a63e 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/empty.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -39,7 +38,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp
index cc560fd6741..fdbc6982374 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp
@@ -122,7 +122,6 @@ int main(int, char**)
                 assert(i->second == d);
             }
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -211,7 +210,6 @@ int main(int, char**)
                 assert(i->second == d);
             }
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::multimap<int, double> C;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
index 5cd15d1d51c..dcb054ccfe1 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
@@ -46,7 +45,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A{});
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
index 89504cfac04..1f4644bea43 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef test_less<int> C;
     const std::multimap<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
@@ -37,7 +36,6 @@ int main(int, char**)
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
index 9b46830ed6d..fb3ac040daf 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef test_less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
@@ -51,7 +50,6 @@ int main(int, char**)
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A{});
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
index 740d12512e8..b6e25bdf840 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -99,7 +98,6 @@ int main(int, char**)
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
index 1a9aadf8a14..e5526d3fcd7 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
     assert(mo.get_allocator() == A(7));
     assert(mo.key_comp() == C(5));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -99,7 +98,6 @@ int main(int, char**)
     assert(mo.get_allocator() == A{});
     assert(mo.key_comp() == C(5));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
index 25c616136c3..fa615f1847e 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
@@ -95,7 +95,6 @@ int main(int, char**)
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -122,7 +121,6 @@ int main(int, char**)
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
index d919a4cd20a..64552f57627 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
     std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> m;
     assert(m.empty());
@@ -50,7 +49,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
index 0d6c63f6385..37b1177135a 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
     assert(*next(m.begin(), 7) == V(3, 1.5));
     assert(*next(m.begin(), 8) == V(3, 2));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -107,7 +106,6 @@ int main(int, char**)
     assert(*next(m.begin(), 8) == V(3, 2));
     assert(m.get_allocator() == a);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
index 291de513d22..8921bd938b6 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
@@ -53,7 +53,6 @@ int main(int, char**)
     assert(*std::next(m.begin(), 7) == V(3, 1.5));
     assert(*std::next(m.begin(), 8) == V(3, 2));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -83,7 +82,6 @@ int main(int, char**)
     assert(*std::next(m.begin(), 7) == V(3, 1.5));
     assert(*std::next(m.begin(), 8) == V(3, 2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
index 1d1e1fd959e..99d2c2c7665 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
     assert(*std::next(m.begin(), 7) == V(3, 1.5));
     assert(*std::next(m.begin(), 8) == V(3, 2));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -119,7 +118,6 @@ int main(int, char**)
     assert(*std::next(m.begin(), 7) == V(3, 1.5));
     assert(*std::next(m.begin(), 8) == V(3, 2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
index b3ca3aab28c..2fb3e1a8281 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -61,7 +60,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
index 363a06bd7f7..f9e99f91934 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
@@ -155,7 +155,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -283,7 +282,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
index a669e90a37a..c73010b29be 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
@@ -86,7 +86,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -153,7 +152,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
index 3db83e292ce..8b0e242f8e6 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
@@ -84,7 +84,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -149,7 +148,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
index 9416f65d41c..1789943bdab 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
@@ -59,12 +59,10 @@ int main(int, char**)
         typedef std::multimap<int, double> Container;
         do_insert_test<Container>();
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> Container;
         do_insert_test<Container>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
index 3dcafc6225c..a2722377ff3 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
@@ -57,12 +57,10 @@ void do_insert_hint_test()
 int main(int, char**)
 {
     do_insert_hint_test<std::multimap<int, double> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         do_insert_hint_test<M>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
index fe0b0e60a35..93defcf03b1 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
@@ -59,7 +59,6 @@ int main(int, char**)
         assert(next(m.begin(), 8)->first == 3);
         assert(next(m.begin(), 8)->second == 2);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
         typedef std::pair<int, double> P;
@@ -97,7 +96,6 @@ int main(int, char**)
         assert(next(m.begin(), 8)->first == 3);
         assert(next(m.begin(), 8)->second == 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
index fb7f73474bc..e5098bddb44 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
         assert(r == 0);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -90,7 +89,6 @@ int main(int, char**)
         assert(r == 0);
     }
     }
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
index 3adaacdfcf2..0440cbe363a 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
@@ -101,7 +101,6 @@ int main(int, char**)
         assert(r.second == m.end());
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -179,7 +178,6 @@ int main(int, char**)
         assert(r.second == m.end());
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::multimap<int, double, std::less<>> M;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
index b4f57620c02..27fcd639923 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
@@ -83,7 +83,6 @@ int main(int, char**)
         assert(r == m.end());
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -143,7 +142,6 @@ int main(int, char**)
         assert(r == m.end());
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::multimap<int, double, std::less<>> M;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
index 0afc87ca082..523bbf618b0 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
@@ -87,7 +87,6 @@ int main(int, char**)
         assert(r == m.end());
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -151,7 +150,6 @@ int main(int, char**)
         assert(r == m.end());
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::multimap<int, double, std::less<>> M;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
index f5b00e39aec..218e23ef9a0 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
@@ -87,7 +87,6 @@ int main(int, char**)
         assert(r == m.end());
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -151,7 +150,6 @@ int main(int, char**)
         assert(r == m.end());
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef std::multimap<int, double, std::less<>> M;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
index 81d52d8154e..b3929d96385 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
@@ -96,7 +96,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -172,7 +171,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
index 21a86a4de35..d5eb078726c 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
@@ -168,7 +168,6 @@ int main(int, char**)
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -278,7 +277,6 @@ int main(int, char**)
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/size.pass.cpp
index 78981745606..788ffcf7165 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/size.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -55,7 +54,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multimap/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multimap/types.pass.cpp
index e604e2139d5..9e2b62f641a 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multimap/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multimap/types.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
@@ -66,7 +65,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/clear.pass.cpp
index 0e470a4a970..19719b59c39 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -61,7 +60,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/count.pass.cpp
index 5bf115bf0fd..37fa979c762 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/count.pass.cpp
@@ -55,7 +55,6 @@ int main(int, char**)
         assert(r == 0);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
@@ -90,7 +89,6 @@ int main(int, char**)
         assert(r == 0);
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/empty.pass.cpp
index fc4c6f647f2..76c1650bb62 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/empty.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
     M m;
@@ -39,7 +38,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/equal_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/equal_range.pass.cpp
index 6faa46ae6d1..cc3bb452d5d 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/equal_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/equal_range.pass.cpp
@@ -100,7 +100,6 @@ int main(int, char**)
         assert(r.second == next(m.begin(), 9));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
@@ -179,7 +178,6 @@ int main(int, char**)
         assert(r.second == next(m.begin(), 9));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter.pass.cpp
index e3eab655b70..6ee4c6df656 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter.pass.cpp
@@ -106,7 +106,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -185,7 +184,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
index e83cf97db69..631b686fc66 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
@@ -78,7 +78,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -137,7 +136,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_key.pass.cpp
index 5f6ada686a5..fc4ac53d20c 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/erase_key.pass.cpp
@@ -72,7 +72,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -125,7 +124,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/find.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/find.pass.cpp
index 8cb4781a529..15434d5235a 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/find.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/find.pass.cpp
@@ -92,7 +92,6 @@ int main(int, char**)
             assert(r == next(m.begin(), 8));
         }
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int V;
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
@@ -163,7 +162,6 @@ int main(int, char**)
             assert(r == next(m.begin(), 8));
         }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_cv.pass.cpp
index 9c83dd74ba5..e49951705c4 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_cv.pass.cpp
@@ -52,12 +52,10 @@ void do_insert_cv_test()
 int main(int, char**)
 {
     do_insert_cv_test<std::multiset<int> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         do_insert_cv_test<M>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
index 39e58055741..e42e00d81ff 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(m.size() == 4);
         assert(*r == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
@@ -69,7 +68,6 @@ int main(int, char**)
         assert(m.size() == 4);
         assert(*r == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
index 675ec8c8b38..33dc7562133 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
@@ -51,7 +51,6 @@ int main(int, char**)
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -81,7 +80,6 @@ int main(int, char**)
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp
index ae0dfdc9bf4..895c16d00f6 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp
@@ -114,7 +114,6 @@ int main(int, char**)
             for (int k = 0; k < 3; ++k, ++i)
                 assert(*i == j);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int V;
         V ar[] =
@@ -195,7 +194,6 @@ int main(int, char**)
             for (int k = 0; k < 3; ++k, ++i)
                 assert(*i == j);
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::multiset<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/lower_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/lower_bound.pass.cpp
index deca98dd6c2..bb394c5fcc5 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/lower_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/lower_bound.pass.cpp
@@ -86,7 +86,6 @@ int main(int, char**)
             assert(r == next(m.begin(), 9));
         }
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int V;
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
@@ -151,7 +150,6 @@ int main(int, char**)
             assert(r == next(m.begin(), 9));
         }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
index b966ac79829..34ea490a27f 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
@@ -68,7 +68,6 @@ int main(int, char**)
         assert(*std::next(mo.begin(), 7) == 3);
         assert(*std::next(mo.begin(), 8) == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int V;
         V ar[] =
@@ -115,7 +114,6 @@ int main(int, char**)
         assert(*std::next(mo.begin(), 7) == 3);
         assert(*std::next(mo.begin(), 8) == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
index 8babf162797..47e0728cf86 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
     assert(mo.get_allocator() == A(7));
     assert(mo.key_comp() == C(5));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::pair<const int, double> V;
     V ar[] =
@@ -98,7 +97,6 @@ int main(int, char**)
     assert(mo.get_allocator() == A{});
     assert(mo.key_comp() == C(5));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
index 53df04bc181..66e767f95fe 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
     std::multiset<int, std::less<int>, min_allocator<int>> m;
     assert(m.empty());
@@ -50,7 +49,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
index c2dc33368e5..510c9d9b059 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     V ar[] =
@@ -79,7 +78,6 @@ int main(int, char**)
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
index 01b64e08f15..e6d6e31bcb8 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
@@ -96,7 +96,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
@@ -173,7 +172,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
index 44bb50afb17..680d1ac271c 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
@@ -167,7 +167,6 @@ int main(int, char**)
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
     {
@@ -277,7 +276,6 @@ int main(int, char**)
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/size.pass.cpp
index 537c2d088d0..83f0c3fac59 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/size.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
     M m;
@@ -55,7 +54,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/types.pass.cpp
index 03e46a6d50e..b84c9f5ed68 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/types.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
@@ -66,7 +65,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/multiset/upper_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/multiset/upper_bound.pass.cpp
index 74d3c4cca1f..7fe58e3fed9 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/multiset/upper_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/multiset/upper_bound.pass.cpp
@@ -86,7 +86,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 9));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
@@ -151,7 +150,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 9));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/clear.pass.cpp
index 9ac10b52c55..2c968183562 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -61,7 +60,6 @@ int main(int, char**)
         m.clear();
         assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/count.pass.cpp
index 9c8808a69db..c1152f4260d 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/count.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
         r = m.count(4);
         assert(r == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int V;
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -92,7 +91,6 @@ int main(int, char**)
         r = m.count(4);
         assert(r == 0);
     }
-#endif
 #if TEST_STD_VER > 2011
     {
         typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/empty.pass.cpp
index 85785a02c02..649e979dbd6 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/empty.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
     M m;
@@ -39,7 +38,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/equal_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/equal_range.pass.cpp
index 2cc031c57ad..dc62cade037 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/equal_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/equal_range.pass.cpp
@@ -158,7 +158,6 @@ int main(int, char**)
         assert(r.second == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -227,7 +226,6 @@ int main(int, char**)
     assert(r.first == next(m.begin(), 8));
     assert(r.second == next(m.begin(), 8));
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter.pass.cpp
index ae9c7732d93..97ce5aee627 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter.pass.cpp
@@ -106,7 +106,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -185,7 +184,6 @@ int main(int, char**)
         assert(i == m.begin());
         assert(i == m.end());
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter_iter.pass.cpp
index f7d9ad26866..1624d2eb68d 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/erase_iter_iter.pass.cpp
@@ -78,7 +78,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -137,7 +136,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/erase_key.pass.cpp
index dfb9430efa2..7add715e9d7 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/erase_key.pass.cpp
@@ -109,7 +109,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -199,7 +198,6 @@ int main(int, char**)
         assert(m.size() == 0);
         assert(i == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/find.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/find.pass.cpp
index c0346bf6438..1ef11401463 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/find.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/find.pass.cpp
@@ -92,7 +92,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -163,7 +162,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/insert_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/insert_cv.pass.cpp
index 042a56e884a..be84186a193 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/insert_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/insert_cv.pass.cpp
@@ -57,12 +57,10 @@ void do_insert_cv_test()
 int main(int, char**)
 {
     do_insert_cv_test<std::set<int> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         do_insert_cv_test<M>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_cv.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_cv.pass.cpp
index b374733170d..1a48310239d 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_cv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_cv.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(m.size() == 3);
         assert(*r == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef M::iterator R;
@@ -69,7 +68,6 @@ int main(int, char**)
         assert(m.size() == 3);
         assert(*r == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp
index 0c169db1dd9..8072493f14a 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
@@ -69,7 +68,6 @@ int main(int, char**)
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/iterator.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/iterator.pass.cpp
index 78dc0f4dfca..10a2ae2524c 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/iterator.pass.cpp
@@ -112,7 +112,6 @@ int main(int, char**)
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
             assert(*i == j);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int V;
         V ar[] =
@@ -191,7 +190,6 @@ int main(int, char**)
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
             assert(*i == j);
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::set<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/lower_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/lower_bound.pass.cpp
index 8190fd1dfb3..73405ff7db4 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/lower_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/lower_bound.pass.cpp
@@ -124,7 +124,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -227,7 +226,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
index f7d28be1e1d..72cee4e5001 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
@@ -94,7 +94,6 @@ int main(int, char**)
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<const int, double> V;
         V ar[] =
@@ -121,7 +120,6 @@ int main(int, char**)
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/default.pass.cpp
index a5c66c9597f..f38f641a7af 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/default.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#if TEST_STD_VER >= 2011
     {
     std::set<int, std::less<int>, min_allocator<int>> m;
     assert(m.empty());
@@ -50,7 +49,6 @@ int main(int, char**)
     assert(m.empty());
     assert(m.begin() == m.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
index abc71e7ddb6..fc03002726b 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     V ar[] =
@@ -67,7 +66,6 @@ int main(int, char**)
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/set.special/member_swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/set.special/member_swap.pass.cpp
index a5ed4badeeb..2601f3375f9 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/set.special/member_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/set.special/member_swap.pass.cpp
@@ -96,7 +96,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -173,7 +172,6 @@ int main(int, char**)
         assert(m2 == m1_save);
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/size.pass.cpp
index f34447dec08..23b63f2e85d 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/size.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
     M m;
@@ -55,7 +54,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/types.pass.cpp
index 5d0806c08d7..f3b63a61cb7 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/types.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::size_t>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     static_assert((std::is_same<C::key_type, int>::value), "");
@@ -66,7 +65,6 @@ int main(int, char**)
     static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/associative/set/upper_bound.pass.cpp b/libcudacxx/libcxx/test/std/containers/associative/set/upper_bound.pass.cpp
index 16ad41cfffc..12672623d41 100644
--- a/libcudacxx/libcxx/test/std/containers/associative/set/upper_bound.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/associative/set/upper_bound.pass.cpp
@@ -124,7 +124,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int V;
     typedef std::set<int, std::less<int>, min_allocator<int>> M;
@@ -227,7 +226,6 @@ int main(int, char**)
         assert(r == next(m.begin(), 8));
     }
     }
-#endif
 #if TEST_STD_VER > 2011
     {
     typedef int V;
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
index 8fdf0c02f1f..a0621d345e9 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
@@ -30,11 +30,9 @@ struct test
         : base(comp, c, a) {}
     test(const value_compare& comp, const container_type& c,
         const test_allocator<int>& a) : base(comp, c, a) {}
-#if TEST_STD_VER >= 2011
     test(const value_compare& comp, container_type&& c,
          const test_allocator<int>& a) : base(comp, std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 
     using base::c;
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
index 6436dddc6f9..e6e98d665b4 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
@@ -30,11 +30,9 @@ struct test
         : base(comp, a) {}
     test(const value_compare& comp, const container_type& c,
         const test_allocator<int>& a) : base(comp, c, a) {}
-#if TEST_STD_VER >= 2011
     test(const value_compare& comp, container_type&& c,
          const test_allocator<int>& a) : base(comp, std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 
     using base::c;
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
index cacda83441b..03840bbfc14 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
@@ -41,11 +41,9 @@ struct test
         : base(comp, a) {}
     test(const value_compare& comp, const container_type& c,
         const test_allocator<int>& a) : base(comp, c, a) {}
-#if TEST_STD_VER >= 2011 // testing rvalue constructor
     test(const value_compare& comp, container_type&& c,
          const test_allocator<int>& a) : base(comp, std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 
     using base::c;
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
index d374894160d..646b6427c39 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
@@ -41,11 +41,9 @@ struct test
         : base(comp, a) {}
     test(const value_compare& comp, const container_type& c,
         const test_allocator<int>& a) : base(comp, c, a) {}
-#if TEST_STD_VER >= 2011 // testing rvalue ctor
     test(const value_compare& comp, container_type&& c,
          const test_allocator<int>& a) : base(comp, std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 
     using base::c;
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
index 5a3b2fdc9ea..0909d4598b4 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
@@ -24,10 +24,8 @@ struct test
 
     explicit test(const test_allocator<int>& a) : base(a) {}
     test(const container_type& c, const test_allocator<int>& a) : base(c, a) {}
-#if TEST_STD_VER >= 2011
     test(container_type&& c, const test_allocator<int>& a) : base(std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
index 5bdfa87938e..97a537b5a1d 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
@@ -37,10 +37,8 @@ struct test
 
     explicit test(const test_allocator<int>& a) : base(a) {}
     test(const container_type& c, const test_allocator<int>& a) : base(c, a) {}
-#if TEST_STD_VER >= 2011
     test(container_type&& c, const test_allocator<int>& a) : base(std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
index ea600e79def..d899e59678a 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
@@ -24,10 +24,8 @@ struct test
 
     explicit test(const test_allocator<int>& a) : base(a) {}
     test(const container_type& c, const test_allocator<int>& a) : base(c, a) {}
-#if TEST_STD_VER >= 2011
     test(container_type&& c, const test_allocator<int>& a) : base(std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
diff --git a/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
index feeee7d47c4..e023d06a9fe 100644
--- a/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
@@ -37,10 +37,8 @@ struct test
 
     explicit test(const test_allocator<int>& a) : base(a) {}
     test(const container_type& c, const test_allocator<int>& a) : base(c, a) {}
-#if TEST_STD_VER >= 2011
     test(container_type&& c, const test_allocator<int>& a) : base(std::move(c), a) {}
     test(test&& q, const test_allocator<int>& a) : base(std::move(q), a) {}
-#endif
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
index c53d3031358..198f7e3f050 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
@@ -15,15 +15,6 @@
 #include <cassert>
 #include "test_macros.h"
 
-// In C++03 the copy assignment operator is not deleted when the implicitly
-// generated operator would be ill-formed; like in the case of a struct with a
-// const member.
-#if TEST_STD_VER < 2011
-#   define TEST_NOT_COPY_ASSIGNABLE(T) ((void)0)
-#else
-#   define TEST_NOT_COPY_ASSIGNABLE(T) static_assert(!std::is_copy_assignable<T>::value, "")
-#endif
-
 struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
@@ -49,7 +40,7 @@ TEST_CONSTEXPR_CXX14 bool tests()
         Array array = {1.1, 2.2, 3.3};
         Array copy = array; (void)copy;
         static_assert(std::is_copy_constructible<Array>::value, "");
-        TEST_NOT_COPY_ASSIGNABLE(Array);
+        static_assert(!std::is_copy_assignable<T>::value, "");
     }
     {
         typedef std::array<double, 0> Array;
@@ -65,7 +56,7 @@ TEST_CONSTEXPR_CXX14 bool tests()
         Array array = {};
         Array copy = array; (void)copy;
         static_assert(std::is_copy_constructible<Array>::value, "");
-        TEST_NOT_COPY_ASSIGNABLE(Array);
+        static_assert(!std::is_copy_assignable<T>::value, "");
     }
     {
         typedef std::array<NoDefault, 0> Array;
@@ -80,7 +71,7 @@ TEST_CONSTEXPR_CXX14 bool tests()
         Array array = {};
         Array copy = array; (void)copy;
         static_assert(std::is_copy_constructible<Array>::value, "");
-        TEST_NOT_COPY_ASSIGNABLE(Array);
+        static_assert(!std::is_copy_assignable<T>::value, "");
     }
 
     // Make sure we can implicitly copy a std::array of a non-trivially copyable type
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/initialization.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/initialization.pass.cpp
index 86cd2027383..126c673b847 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/initialization.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/array.cons/initialization.pass.cpp
@@ -39,7 +39,6 @@ struct test_nondefault_initialization {
     TEST_CONSTEXPR_CXX14 void operator()() const
     {
         // Check direct-list-initialization syntax (introduced in C++11)
-    #if TEST_STD_VER >= 2011
         {
             {
                 std::array<T, 0> a0_0{}; (void)a0_0;
@@ -62,7 +61,6 @@ struct test_nondefault_initialization {
 
             std::array<NoDefault, 0> nodefault{}; (void)nodefault;
         }
-    #endif
 
         // Check copy-list-initialization syntax
         {
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data.pass.cpp
index 1bb46e226fb..bd87e5ff61e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data.pass.cpp
@@ -21,15 +21,6 @@ struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
-#if TEST_STD_VER < 2011
-struct natural_alignment {
-    long t1;
-    long long t2;
-    double t3;
-    long double t4;
-};
-#endif
-
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
@@ -85,11 +76,7 @@ int main(int, char**)
 
     // Test the alignment of data()
     {
-#if TEST_STD_VER < 2011
-        typedef natural_alignment T;
-#else
         typedef std::max_align_t T;
-#endif
         typedef std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data_const.pass.cpp
index 7add1808eec..4a5cf2e0bb1 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/array.data/data_const.pass.cpp
@@ -21,15 +21,6 @@ struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
-#if TEST_STD_VER < 2011
-struct natural_alignment {
-    long t1;
-    long long t2;
-    double t3;
-    long double t4;
-};
-#endif
-
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     {
@@ -76,11 +67,7 @@ int main(int, char**)
 
     // Test the alignment of data()
     {
-#if TEST_STD_VER < 2011
-        typedef natural_alignment T;
-#else
         typedef std::max_align_t T;
-#endif
         typedef std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/array.size/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/array.size/size.pass.cpp
index 75835ba813c..1bb4ee1ce66 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/array.size/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/array.size/size.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
         assert(c.max_size() == 0);
         assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef double T;
         typedef std::array<T, 3> C;
@@ -50,7 +49,6 @@ int main(int, char**)
         static_assert(c.max_size() == 0, "");
         static_assert(c.empty(), "");
     }
-#endif
 
     return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/array.special/swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/array.special/swap.pass.cpp
index 6335dbe8d46..b2dd13bfe1c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/array.special/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/array.special/swap.pass.cpp
@@ -66,11 +66,8 @@ TEST_CONSTEXPR_CXX20 bool tests()
         C0 l = {};
         C0 r = {};
         swap(l, r);
-#if TEST_STD_VER >= 2011
         static_assert(noexcept(swap(l, r)), "");
-#endif
     }
-#if TEST_STD_VER >= 2011
     {
         // NonSwappable is still considered swappable in C++03 because there
         // is no access control SFINAE.
@@ -78,7 +75,6 @@ TEST_CONSTEXPR_CXX20 bool tests()
         typedef std::array<T, 42> C1;
         static_assert(!can_swap<C1&>::value, "");
     }
-#endif
 
     return true;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/array.swap/swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/array.swap/swap.pass.cpp
index 0ba3c0d4d9e..26a662bef84 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/array.swap/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/array.swap/swap.pass.cpp
@@ -80,9 +80,7 @@ TEST_CONSTEXPR_CXX20 bool tests()
         C0 l = {};
         C0 r = {};
         l.swap(r);
-#if TEST_STD_VER >= 2011
         static_assert(noexcept(l.swap(r)), "");
-#endif
     }
 
     return true;
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/empty.pass.cpp
index 3778b8b9d2c..15822931133 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/empty.pass.cpp
@@ -42,13 +42,11 @@ int main(int, char**)
     static_assert(tests(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     // Sanity check for constexpr in C++11
     {
         constexpr std::array<int, 3> array = {};
         static_assert(!array.empty(), "");
     }
-#endif
 
     return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/max_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/max_size.pass.cpp
index 38a73269709..e8bdc0ea591 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/max_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/max_size.pass.cpp
@@ -42,13 +42,11 @@ int main(int, char**)
     static_assert(tests(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     // Sanity check for constexpr in C++11
     {
         constexpr std::array<int, 3> array = {};
         static_assert(array.max_size() == 3, "");
     }
-#endif
 
     return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp
index 00e9bcd3258..9abd53d27d4 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp
@@ -47,7 +47,6 @@ void test_type() {
   test<T, 0>();
 }
 
-#if TEST_STD_VER >= 2011
 struct alignas(alignof(std::max_align_t) * 2) TestType1 {
 
 };
@@ -59,7 +58,6 @@ struct alignas(alignof(std::max_align_t) * 2) TestType2 {
 struct alignas(alignof(std::max_align_t)) TestType3 {
   char data[1000];
 };
-#endif
 
 int main(int, char**) {
   test_type<char>();
@@ -67,12 +65,10 @@ int main(int, char**) {
   test_type<double>();
   test_type<long double>();
 
-#if TEST_STD_VER >= 2011
   test_type<std::max_align_t>();
   test_type<TestType1>();
   test_type<TestType2>();
   test_type<TestType3>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
index b035157c396..7dec36c99fe 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
@@ -83,7 +83,6 @@ int main(int, char**)
         assert(c.front() == 0);
         assert(c.back() == 9);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::deque<int, min_allocator<int>> C;
         C c = make<std::deque<int, min_allocator<int>> >(10);
@@ -116,7 +115,6 @@ int main(int, char**)
         assert(c.front() == 0);
         assert(c.back() == 9);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
index 762c5418041..e6721e62fa8 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::deque<int, min_allocator<int>> C;
     C c;
@@ -41,7 +40,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
index 1d08966011a..c56e81c8f4f 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
@@ -75,7 +75,6 @@ int main(int, char**)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -84,7 +83,6 @@ int main(int, char**)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
index 8127d088e5c..328026b3612 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
@@ -75,7 +75,6 @@ int main(int, char**)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -84,7 +83,6 @@ int main(int, char**)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
index d48ae96a6df..c3db5dc2ba4 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
@@ -64,7 +64,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -72,7 +71,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
index 8d2c2a69965..af60abb6631 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::deque<int, min_allocator<int>> C;
     C c;
@@ -57,7 +56,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
index a1367b2665c..dfae727fe0d 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
@@ -31,12 +31,10 @@ int main(int, char**)
 {
     test<int>(std::allocator<int>());
     test<NotConstructible>(test_allocator<NotConstructible>(3));
-#if TEST_STD_VER >= 2011
     test<int>(min_allocator<int>());
     test<NotConstructible>(min_allocator<NotConstructible>{});
     test<int>(explicit_allocator<int>());
     test<NotConstructible>(explicit_allocator<NotConstructible>{});
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
index 908ec28b9c8..07c8ff75862 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -18,9 +18,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
-#if TEST_STD_VER >= 2011
 #include "emplace_constructible.h"
-#endif
 
 template <class C>
 C
@@ -93,7 +91,6 @@ void basic_test()
                 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     testNI<std::deque<int> >(1500, 2000, 1000);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -103,11 +100,9 @@ void basic_test()
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     testNI<std::deque<int, min_allocator<int>> >(1500, 2000, 1000);
     }
-#endif
 }
 
 void test_emplacable_concept() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -146,7 +141,6 @@ void test_emplacable_concept() {
       assert(v[2].value == 42);
     }
   }
-#endif
 }
 
 int main(int, char**) {
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
index 599f9867f61..1bd0620bd66 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
@@ -70,7 +70,6 @@ int main(int, char**)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -79,7 +78,6 @@ int main(int, char**)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
index 9ba78e7a9b9..ffd64c1c659 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
-#if TEST_STD_VER >= 2011
     {
         std::deque<int, other_allocator<int> > v(3, 2, other_allocator<int>(5));
         std::deque<int, other_allocator<int> > v2 = v;
@@ -56,7 +55,6 @@ int main(int, char**)
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
index d18a673c612..cc1c401ff7a 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
@@ -40,14 +40,12 @@ int main(int, char**)
         test(std::deque<int, other_allocator<int> >(ab, an, other_allocator<int>(3)),
                                                             other_allocator<int>(4));
     }
-#if TEST_STD_VER >= 2011
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int, min_allocator<int> >(ab, an, min_allocator<int>()),
                                                           min_allocator<int>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
index b2c62d384d6..3f6004e3992 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
@@ -24,20 +24,16 @@ test()
 {
     std::deque<T, Allocator> d;
     assert(d.size() == 0);
-#if TEST_STD_VER >= 2011
     std::deque<T, Allocator> d1 = {};
     assert(d1.size() == 0);
-#endif
 }
 
 int main(int, char**)
 {
     test<int, std::allocator<int> >();
     test<NotConstructible, limited_allocator<NotConstructible, 1> >();
-#if TEST_STD_VER >= 2011
     test<int, min_allocator<int> >();
     test<NotConstructible, min_allocator<NotConstructible> >();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
index 8f23344d7bf..5762c9836b3 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -18,9 +18,7 @@
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
-#if TEST_STD_VER >= 2011
 #include "emplace_constructible.h"
-#endif
 
 template <class InputIterator>
 void
@@ -60,14 +58,11 @@ void basic_test()
     test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an));
     test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an));
     test<limited_allocator<int, 4096> >(ab, an);
-#if TEST_STD_VER >= 2011
     test<min_allocator<int> >(ab, an);
-#endif
 }
 
 
 void test_emplacable_concept() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -102,7 +97,6 @@ void test_emplacable_concept() {
       assert(v[2].value == 42);
     }
   }
-#endif
 }
 
 int main(int, char**) {
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
index 4a34d391373..3a6ad9e684c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -19,9 +19,7 @@
 #include "test_iterators.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
-#if TEST_STD_VER >= 2011
 #include "emplace_constructible.h"
-#endif
 
 template <class InputIterator, class Allocator>
 void
@@ -46,17 +44,14 @@ void basic_test()
     test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), test_allocator<int>(4));
     test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), test_allocator<int>(5));
     test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), test_allocator<int>(6));
-#if TEST_STD_VER >= 2011
     test(cpp17_input_iterator<const int*>(ab), cpp17_input_iterator<const int*>(an), min_allocator<int>());
     test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), min_allocator<int>());
     test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), min_allocator<int>());
     test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), min_allocator<int>());
-#endif
 }
 
 
 void test_emplacable_concept() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -93,7 +88,6 @@ void test_emplacable_concept() {
       assert(v[2].value == 42);
     }
   }
-#endif
 }
 
 int main(int, char**) {
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
index bec1dfbe3c3..42d666f6f17 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
-#if TEST_STD_VER >= 2011
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
@@ -59,7 +58,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
index cfc191a4c5f..13d64f20cb5 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
@@ -53,10 +53,8 @@ test1(unsigned n)
     assert(static_cast<unsigned>(DefaultOnly::count) == n);
     assert(d.size() == n);
     assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
-#if TEST_STD_VER >= 2011
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == T());
-#endif
     }
     assert(DefaultOnly::count == 0);
 }
@@ -103,9 +101,7 @@ int main(int, char**)
 
     LIBCPP_ONLY(test1<DefaultOnly, limited_allocator<DefaultOnly, 4096> >(4095));
 
-#if TEST_STD_VER >= 2011
     test<DefaultOnly, min_allocator<DefaultOnly> >(4095);
-#endif
 
 #if TEST_STD_VER > 2011
     test3<DefaultOnly, std::allocator<DefaultOnly>> (1023);
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
index 22039ca9c81..6998f89af57 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
@@ -46,9 +46,7 @@ int main(int, char**)
     test<int, std::allocator<int> >(4096, 1165);
     test<int, std::allocator<int> >(4097, 157);
     LIBCPP_ONLY(test<int, limited_allocator<int, 4096> >(4095, 90));
-#if TEST_STD_VER >= 2011
     test<int, min_allocator<int> >(4095, 90);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
index 124de52450c..2ebc753fd01 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
     test(4096, 1165, a);
     test(4097, 157, a);
     }
-#if TEST_STD_VER >= 2011
     {
     min_allocator<int> a;
     test(0, 5, a);
@@ -64,7 +63,6 @@ int main(int, char**)
     test(4096, 1165, a);
     test(4097, 157, a);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
index f7be6cfdff9..cd154901d45 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         c.clear();
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef NotConstructible T;
         typedef std::deque<T, min_allocator<T>> C;
@@ -62,7 +61,6 @@ int main(int, char**)
         c.clear();
         assert(distance(c.begin(), c.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
index b00e53708fc..fdb900ddbf0 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
@@ -97,7 +97,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -105,7 +104,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 // Test for LWG2953:
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
index 5d0c3cb96cc..919b7cd6cdf 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
@@ -104,7 +104,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -112,7 +111,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
 // Test for LWG2953:
 // Throws: Nothing unless an exception is thrown by the assignment operator of T.
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
index b0bb00cf950..61f0aebd691 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
@@ -237,7 +237,6 @@ template <class C>
 void
 test_move()
 {
-#if TEST_STD_VER >= 2011
     C c;
     typedef typename C::const_iterator CI;
     {
@@ -256,7 +255,6 @@ test_move()
     j = 0;
     for (CI i = c.begin(); i != c.end(); ++i, (void)++j)
         assert(*i == MoveOnly(j));
-#endif
 }
 
 int main(int, char**)
@@ -269,11 +267,8 @@ int main(int, char**)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     testNI<std::deque<int> >(1500, 2000, 1000);
-#if TEST_STD_VER >= 2011
     test_move<std::deque<MoveOnly, limited_allocator<MoveOnly, 2000> > >();
-#endif
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -284,7 +279,6 @@ int main(int, char**)
     testNI<std::deque<int> >(1500, 2000, 1000);
     test_move<std::deque<MoveOnly, min_allocator<MoveOnly> > >();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
index aada2abbea1..9eaae99fe44 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
@@ -143,7 +143,6 @@ int main(int, char**)
                 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     self_reference_test<std::deque<int> >();
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -153,7 +152,6 @@ int main(int, char**)
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
index e374c8e17f1..6050a94e141 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
@@ -124,7 +124,6 @@ int main(int, char**)
             testN<std::deque<int> >(rng[i], rng[j]);
     self_reference_test<std::deque<int> >();
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -133,7 +132,6 @@ int main(int, char**)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
index 2d3aa740995..14aa4c5b702 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
@@ -73,7 +73,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -81,7 +80,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
index a5d441d2ccd..05f21aef1fe 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
@@ -73,7 +73,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -81,7 +80,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
index 4445c17ada2..977dcedd280 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
@@ -62,14 +62,12 @@ int main(int, char**)
     for (int j = 0; j < N; ++j)
         test<std::deque<int> >(rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int j = 0; j < N; ++j)
         test<std::deque<int, min_allocator<int>> >(rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
index 929b6f9393d..b70da64ff1b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
@@ -72,7 +72,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
    {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -80,7 +79,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
index 256ff87f566..4224b2a2420 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
@@ -76,7 +76,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -84,7 +83,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
index f7628acf0cb..b93ebb4d34c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
@@ -75,7 +75,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -83,7 +82,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp
index aa7bd94ee8d..31770a8eda9 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp
@@ -75,7 +75,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -83,7 +82,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
index 255470450cf..f9f62670a23 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
@@ -75,7 +75,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int> >(rng[i], rng[j]);
     }
-#if TEST_STD_VER >= 2011
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
@@ -83,7 +82,6 @@ int main(int, char**)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int> > >(rng[i], rng[j]);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
index b06ba1a5174..cf5ce853f29 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
@@ -85,7 +85,6 @@ int main(int, char**)
         assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A(1));
     }
-#if TEST_STD_VER >= 2011
     {
         int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
         const int N = sizeof(rng)/sizeof(rng[0]);
@@ -106,7 +105,6 @@ int main(int, char**)
         assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/iterators.pass.cpp
index 3281f46744b..a6d6e36191e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/iterators.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     j = c.cbegin();
     assert(i == j);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::deque<int, min_allocator<int>> C;
     C c;
@@ -43,7 +42,6 @@ int main(int, char**)
     j = c.cbegin();
     assert(i == j);
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         std::deque<int>::iterator ii1{}, ii2{};
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/deque/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/deque/types.pass.cpp
index 5bfdeb2ce1d..b70b1581ce9 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/deque/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/deque/types.pass.cpp
@@ -80,7 +80,6 @@ int main(int, char**)
     static_assert((std::is_same<std::deque<char>::allocator_type,
                                 std::allocator<char> >::value), "");
 
-#if TEST_STD_VER >= 2011
     {
         typedef std::deque<short, min_allocator<short>> C;
         static_assert((std::is_same<C::value_type, short>::value), "");
@@ -100,7 +99,6 @@ int main(int, char**)
         static_assert((std::is_same<typename C::difference_type,
             typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/empty.pass.cpp
index c7d0549fc2b..eff76c3c2ed 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::forward_list<int, min_allocator<int>> C;
     C c;
@@ -41,7 +40,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
index e7e0e6fe90c..ada35ac81b5 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
         assert(c.front() == 0);
         assert(*c.begin() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -57,7 +56,6 @@ int main(int, char**)
         assert(c.front() == 0);
         assert(*c.begin() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
index 1c4c4dba01c..5ba75ac3ba0 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
@@ -28,7 +28,6 @@ int main(int, char**)
         assert(c.get_allocator() == A(12));
         assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef min_allocator<NotConstructible> A;
         typedef A::value_type T;
@@ -45,7 +44,6 @@ int main(int, char**)
         assert(c.get_allocator() == A());
         assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
index 25506a79eec..d15c559cd01 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
@@ -117,7 +117,6 @@ int main(int, char**)
         assert(c1 == c0);
         assert(c1.get_allocator() == A(10));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef min_allocator<int> A;
@@ -142,7 +141,6 @@ int main(int, char**)
         assert(c1 == c0);
         assert(c1.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
index b20208a51c2..35a580bea4c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
             assert(*i == 10+n);
         assert(n == 4);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -74,7 +73,6 @@ int main(int, char**)
             assert(*i == 10+n);
         assert(n == 4);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
index 031ae34f4bc..ca5a464549b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
@@ -41,7 +41,6 @@ int main(int, char**)
             assert(*i == 10);
         assert(n == 4);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -64,7 +63,6 @@ int main(int, char**)
             assert(*i == 10);
         assert(n == 4);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
index 59ca0ed6a3b..97dd2a3cfaf 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
         assert(c == c0);
         assert(c.get_allocator() == A(10));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef other_allocator<int> A;
@@ -63,7 +62,6 @@ int main(int, char**)
         assert(c == c0);
         assert(c.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
index fa96c04da99..1d32b8855f2 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(c == c0);
         assert(c.get_allocator() == A(9));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef min_allocator<int> A;
@@ -63,7 +62,6 @@ int main(int, char**)
         assert(c == c0);
         assert(c.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
index 8d8137e8182..3aca47b9060 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
@@ -24,7 +24,6 @@ int main(int, char**)
         C c;
         assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -37,7 +36,6 @@ int main(int, char**)
         C c = {};
         assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
index 0524ee116ee..2873006291e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -44,7 +43,6 @@ int main(int, char**)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
index 71e0df03f47..2d55880ee69 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
@@ -36,7 +36,6 @@ int main(int, char**)
         assert(n == std::end(t) - std::begin(t));
         assert(c.get_allocator() == A(13));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef min_allocator<T> A;
@@ -50,7 +49,6 @@ int main(int, char**)
         assert(n == std::end(t) - std::begin(t));
         assert(c.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
index 249d3f80f38..69c9fe7cf3c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
@@ -48,15 +48,10 @@ int main(int, char**)
         unsigned n = 0;
 
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, (void)++n) {
-#if TEST_STD_VER >= 2011
             assert(*i == T());
-#else
-            ((void)0);
-#endif
         }
         assert(n == N);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef DefaultOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -69,7 +64,6 @@ int main(int, char**)
         check_allocator<T, min_allocator<T>> ( 0 );
         check_allocator<T, min_allocator<T>> ( 3 );
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
index e954e5cd8c3..d5265bcd36d 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
             assert(*i == v);
         assert(n == N);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -41,7 +40,6 @@ int main(int, char**)
             assert(*i == v);
         assert(n == N);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
index bc46ce6c7b9..abd8692ff91 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         assert(n == N);
         assert(c.get_allocator() == A(12));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef min_allocator<int> A;
         typedef A::value_type T;
@@ -46,7 +45,6 @@ int main(int, char**)
         assert(n == N);
         assert(c.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
index ee5e0b618da..fda5afde845 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
@@ -60,7 +60,6 @@ int main(int, char**)
         C::const_iterator i = c.before_begin();
         assert(std::distance(i, c.end()) == 11);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -100,7 +99,6 @@ int main(int, char**)
         C::const_iterator i = c.before_begin();
         assert(std::distance(i, c.end()) == 11);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
index 0dc9d0864d7..904f3fb008b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
@@ -71,7 +71,6 @@ int main(int, char**)
         C::iterator i;
         C::const_iterator j;
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -119,7 +118,6 @@ int main(int, char**)
         C::iterator i;
         C::const_iterator j;
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         std::forward_list<int>::iterator ii1{}, ii2{};
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
index 3896c8b7d2f..9cc02ab3ea1 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         c.clear();
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef NotConstructible T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -62,7 +61,6 @@ int main(int, char**)
         c.clear();
         assert(distance(c.begin(), c.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
index e61db3b38cc..51392badd1a 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
@@ -84,7 +84,6 @@ int main(int, char**)
         assert(i == c.end());
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -151,7 +150,6 @@ int main(int, char**)
         assert(i == c.end());
         assert(distance(c.begin(), c.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
index ef484e16b0f..0799f945115 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
@@ -55,7 +55,6 @@ int main(int, char**)
         assert(i == c.end());
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -93,7 +92,6 @@ int main(int, char**)
         assert(i == c.end());
         assert(distance(c.begin(), c.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
index 0923c3e01f0..750aa76aafd 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
         assert(*next(c.begin(), 3) == 2);
         assert(distance(c.begin(), c.end()) == 4);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -83,7 +82,6 @@ int main(int, char**)
         assert(*next(c.begin(), 3) == 2);
         assert(distance(c.begin(), c.end()) == 4);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
index 81ff85d329f..307985afad3 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -76,7 +75,6 @@ int main(int, char**)
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
index b4e731b8542..967586e58c4 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
         assert(*next(c.begin(), 3) == 3);
         assert(*next(c.begin(), 4) == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -69,7 +68,6 @@ int main(int, char**)
         assert(*next(c.begin(), 3) == 3);
         assert(*next(c.begin(), 4) == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
index 01fabd97c16..b1e1917f9fb 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         c.pop_front();
         assert(distance(c.begin(), c.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef MoveOnly T;
         typedef std::forward_list<T> C;
@@ -70,7 +69,6 @@ int main(int, char**)
         c.pop_front();
         assert(distance(c.begin(), c.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
index 55ef58344d3..0f14a4ba317 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
         assert(*next(c.begin()) == 1);
         assert(distance(c.begin(), c.end()) == 2);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -43,7 +42,6 @@ int main(int, char**)
         assert(*next(c.begin()) == 1);
         assert(distance(c.begin(), c.end()) == 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
index cecf66f21e6..2089e6caa70 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
@@ -64,7 +64,6 @@ int main(int, char**)
         assert(*next(c.begin(), 4) == 0);
         assert(*next(c.begin(), 5) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef DefaultOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -110,7 +109,6 @@ int main(int, char**)
         assert(*next(c.begin(), 4) == 0);
         assert(*next(c.begin(), 5) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
index 297b12aedb2..c0d440c0521 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
@@ -17,9 +17,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
 #include "container_test_types.h"
-#endif
 
 int main(int, char**)
 {
@@ -53,7 +51,6 @@ int main(int, char**)
         assert(*next(c.begin(), 4) == 10);
         assert(*next(c.begin(), 5) == 10);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -97,7 +94,6 @@ int main(int, char**)
             assert(!cc->unchecked());
         }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
index 3fdf84ca404..73ddc88ce5e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
@@ -31,7 +31,6 @@ int main(int, char**)
         C c3(std::begin(t3), std::end(t3));
         assert(c1 == c3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -44,7 +43,6 @@ int main(int, char**)
         C c3(std::begin(t3), std::end(t3));
         assert(c1 == c3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
index efe4facb19a..d69653e47e0 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         C c3(std::begin(t3), std::end(t3));
         assert(c1 == c3);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -45,7 +44,6 @@ int main(int, char**)
         C c3(std::begin(t3), std::end(t3));
         assert(c1 == c3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
index 23d14e74903..db321525a13 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
@@ -119,7 +119,6 @@ int main(int, char**)
         }
     assert ( it == c.end ());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -167,7 +166,6 @@ int main(int, char**)
         do_remove(c1, 0, 1);
         assert(c1 == c2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
index 44c196de8e9..212c0cf9e79 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
@@ -128,7 +128,6 @@ int main(int, char**)
     assert(c.empty());
     }
 
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
@@ -191,7 +190,6 @@ int main(int, char**)
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
index 9e79a5b7e57..0795f7fcbb8 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
@@ -35,10 +35,8 @@ int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int> >(i);
-#if TEST_STD_VER >= 2011
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
index 93e41216aac..c744bf2418f 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
@@ -83,10 +83,8 @@ int main(int, char**)
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
-#if TEST_STD_VER >= 2011
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
-#endif
 
     for (int i = 0; i < 40; ++i)
         test_stable(i);
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
index 77759f248cf..0c4e36d2cec 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
@@ -86,10 +86,8 @@ int main(int, char**)
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
-#if TEST_STD_VER >= 2011
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
-#endif
 
     for (int i = 0; i < 40; ++i)
         test_stable(i);
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
index 5bd2c5ba6d5..51d5e054e7c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
         }
     }
     }
-#if TEST_STD_VER >= 2011
     {
     // splicing different containers
     typedef std::forward_list<T, min_allocator<T>> C;
@@ -72,7 +71,6 @@ int main(int, char**)
         }
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
index 16683f72a24..a59ad8647bb 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
@@ -106,7 +106,6 @@ int main(int, char**)
         }
     }
     }
-#if TEST_STD_VER >= 2011
     {
     // splicing different containers
     typedef std::forward_list<T, min_allocator<T>> C;
@@ -136,7 +135,6 @@ int main(int, char**)
         }
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
index 125b7cd14b9..5abb10273cc 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
@@ -122,7 +122,6 @@ int main(int, char**)
         }
     }
     }
-#if TEST_STD_VER >= 2011
     {
     // splicing different containers
     typedef std::forward_list<T, min_allocator<T>> C;
@@ -166,7 +165,6 @@ int main(int, char**)
         }
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
index 1eef80eac9a..01d648ef8db 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
@@ -82,7 +82,6 @@ int main(int, char**)
         do_unique(c1, 2);
         assert(c1 == c2);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -131,7 +130,6 @@ int main(int, char**)
         do_unique(c1, 2);
         assert(c1 == c2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
index 39a8faebc29..db65c2e49bb 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
@@ -113,7 +113,6 @@ int main(int, char**)
     assert(c1.empty());
     }
 
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
@@ -162,7 +161,6 @@ int main(int, char**)
         do_unique(c1, g, 2);
         assert(c1 == c2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/incomplete.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
index cef7d521128..af1e1c6d01a 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
@@ -24,14 +24,12 @@ struct A {
   std::forward_list<A>::const_iterator it2;
 };
 
-#if TEST_STD_VER >= 2011
 struct B {
   typedef std::forward_list<B, min_allocator<B>> FList;
   FList d;
   FList::iterator it;
   FList::const_iterator it2;
 };
-#endif
 
 int main(int, char**)
 {
@@ -41,14 +39,12 @@ int main(int, char**)
     a.it = a.d.begin();
     a.it2 = a.d.cbefore_begin();
   }
-#if TEST_STD_VER >= 2011
   {
     B b;
     assert(b.d.empty());
     b.it = b.d.begin();
     b.it2 = b.d.cbefore_begin();
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/types.pass.cpp
index 6c930ff0b06..3d69ab17677 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/forwardlist/types.pass.cpp
@@ -52,7 +52,6 @@ int main(int, char**)
     static_assert((std::is_same<typename C::difference_type,
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::forward_list<char, min_allocator<char>> C;
     static_assert((std::is_same<C::value_type, char>::value), "");
@@ -72,7 +71,6 @@ int main(int, char**)
     static_assert((std::is_same<typename C::difference_type,
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/iterators.pass.cpp
index 90eb241bb76..de45c1d8a97 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/iterators.pass.cpp
@@ -77,7 +77,6 @@ int main(int, char**)
         C::iterator i;
         C::const_iterator j;
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::list<T, min_allocator<T>> C;
@@ -134,7 +133,6 @@ int main(int, char**)
         C::const_iterator j = i;
         assert(j->first == 3);
     }
-#endif
 #if TEST_STD_VER > 2011
     {
         std::list<int>::iterator ii1{}, ii2{};
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
index c524bf44722..985d1207183 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::list<int, min_allocator<int>> C;
     C c;
@@ -41,7 +40,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
index a8ceb6de272..ce2c6b06101 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(std::distance(l.begin(), l.end()) == 20);
     }
 #endif  // __LIBCUDACXX_MOVE
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l(5, 2);
         l.resize(2);
@@ -77,7 +76,6 @@ int main(int, char**)
         assert(std::distance(l.begin(), l.end()) == 20);
     }
 #endif  // __LIBCUDACXX_MOVE
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
index 290b5dfb488..76e6a446bac 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
         assert(l.front() == 2);
         assert(l.back() == 3.5);
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<double, min_allocator<double>> l(5, 2);
         l.resize(2, 3.5);
@@ -49,7 +48,6 @@ int main(int, char**)
         assert(l.front() == 2);
         assert(l.back() == 3.5);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/size.pass.cpp
index ceafaaf35a7..749f1a008e5 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.capacity/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::list<int, min_allocator<int>> C;
     C c;
@@ -57,7 +56,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
index 2e8476db9a3..f1388be44b9 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
@@ -40,7 +39,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy.pass.cpp
index aabf7b836f7..76d9b1cfdfc 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy.pass.cpp
@@ -31,7 +31,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == l.get_allocator());
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, other_allocator<int> > l(3, 2, other_allocator<int>(5));
         std::list<int, other_allocator<int> > l2 = l;
@@ -49,7 +48,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == l.get_allocator());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
index 0d51e00f1fe..7e8a9825dc1 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
@@ -31,14 +31,12 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(3));
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default.pass.cpp
index b30004a9964..beea10ed066 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l;
         assert(l.size() == 0);
@@ -64,7 +63,6 @@ int main(int, char**)
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
index 130df34b60e..84748c51647 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l;
         assert(l.size() == 0);
@@ -44,7 +43,6 @@ int main(int, char**)
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
index 9becf8f6be3..3b5f4231071 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -17,10 +17,8 @@
 #include "test_iterators.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
-#if TEST_STD_VER >= 2011
 #include "emplace_constructible.h"
 #include "container_test_types.h"
-#endif
 
 void basic_test()
 {
@@ -56,7 +54,6 @@ void basic_test()
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
-#if TEST_STD_VER >= 2011
     {
         int a[] = {0, 1, 2, 3};
         std::list<int, min_allocator<int>> l(cpp17_input_iterator<const int*>(a),
@@ -78,13 +75,11 @@ void basic_test()
         for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
-#endif
 }
 
 
 
 void test_emplacable_concept() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -125,13 +120,11 @@ void test_emplacable_concept() {
       assert(I->value == 42);
     }
   }
-#endif
 }
 
 
 
 void test_emplacable_concept_with_alloc() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -174,11 +167,9 @@ void test_emplacable_concept_with_alloc() {
       assert(I->value == 42);
     }
   }
-#endif
 }
 
 void test_ctor_under_alloc() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -205,11 +196,9 @@ void test_ctor_under_alloc() {
       C v(It(arr2), It(std::end(arr2)));
     }
   }
-#endif
 }
 
 void test_ctor_under_alloc_with_alloc() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -240,7 +229,6 @@ void test_ctor_under_alloc_with_alloc() {
       C v(It(arr2), It(std::end(arr2)), a);
     }
   }
-#endif
 }
 
 
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_type.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
index d7955cc033e..9ee495e661e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
@@ -77,7 +77,6 @@ int main(int, char**)
         test3<int, min_allocator<int>> (3);
     }
 #endif
-#if TEST_STD_VER >= 2011
     {
         std::list<DefaultOnly> l(3);
         assert(l.size() == 3);
@@ -99,7 +98,6 @@ int main(int, char**)
         assert(l.size() == 3);
         assert(std::distance(l.begin(), l.end()) == 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
index 8ffd90a9ff1..a58dc8ffe7e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
@@ -53,7 +53,6 @@ int main(int, char**)
         ++i;
         assert(*i == 2);
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l(3, 2);
         assert(l.size() == 3);
@@ -76,7 +75,6 @@ int main(int, char**)
         ++i;
         assert(*i == 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
index f8437886c39..402c85ddfcf 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     int a[] = {1, 2, 3};
     std::list<int, min_allocator<int>> c(a, a+3);
@@ -33,7 +32,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
index 4daf5ffbace..aa33ab6d1f1 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
@@ -39,7 +39,6 @@ int main(int, char**)
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {1, 2, 3};
     std::list<int, min_allocator<int>> l1(a1, a1+3);
@@ -61,7 +60,6 @@ int main(int, char**)
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
index dc7a435cb94..adaf078b540 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
@@ -80,7 +79,6 @@ int main(int, char**)
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
index 4c16b0ccb06..c406bc86e14 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
@@ -84,9 +84,7 @@ void test() {
 int main(int, char**)
 {
     test<std::list<int> >();
-#if TEST_STD_VER >= 2011
     test<std::list<int, min_allocator<int>>>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
index c468543c866..196bfd53f2d 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
@@ -47,9 +47,7 @@ void test() {
 int main(int, char**)
 {
     test<std::list<int> >();
-#if TEST_STD_VER >= 2011
     test<std::list<int, min_allocator<int>>>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
index 8774cd2f9b8..eb579c9924c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
@@ -49,9 +49,7 @@ void test()
 int main(int, char**)
 {
     test<std::list<int> >();
-#if TEST_STD_VER >= 2011
     test<std::list<int, min_allocator<int>>>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
index e509c6a25d7..e09f976d657 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
@@ -28,7 +28,6 @@ int main(int, char**)
     c.pop_back();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     int a[] = {1, 2, 3};
     std::list<int, min_allocator<int>> c(a, a+3);
@@ -39,7 +38,6 @@ int main(int, char**)
     c.pop_back();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
index 34f86b84ebc..703a7e86d34 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
@@ -28,7 +28,6 @@ int main(int, char**)
     c.pop_front();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     int a[] = {1, 2, 3};
     std::list<int, min_allocator<int>> c(a, a+3);
@@ -39,7 +38,6 @@ int main(int, char**)
     c.pop_front();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
index 7eb400ee8e7..110777a4dc7 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     int a[] = {0, 1, 2, 3, 4};
     assert(c == std::list<int>(a, a+5));
     }
-#if TEST_STD_VER >= 2011
     {
     std::list<int, min_allocator<int>> c;
     for (int i = 0; i < 5; ++i)
@@ -33,7 +32,6 @@ int main(int, char**)
     int a[] = {0, 1, 2, 3, 4};
     assert((c == std::list<int, min_allocator<int>>(a, a+5)));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
index e5f193f272a..7b5eeac2418 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     int a[] = {4, 3, 2, 1, 0};
     assert(c == std::list<int>(a, a+5));
     }
-#if TEST_STD_VER >= 2011
     {
     std::list<int, min_allocator<int>> c;
     for (int i = 0; i < 5; ++i)
@@ -33,7 +32,6 @@ int main(int, char**)
     int a[] = {4, 3, 2, 1, 0};
     assert((c == std::list<int, min_allocator<int>>(a, a+5)));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge.pass.cpp
index c0521b2d03f..2111673ff25 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     assert((c1 == std::list<int>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
     }
 
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {1, 3, 7, 9, 10};
     int a2[] = {0, 2, 4, 5, 6, 8, 11};
@@ -48,7 +47,6 @@ int main(int, char**)
     assert((c1 == std::list<int, min_allocator<int>>(a3, a3+sizeof(a3)/sizeof(a3[0]))));
     assert(c2.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
index 394c951010e..76b8c2e5610 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     assert((c1 == std::list<int>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
     }
 
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {10, 9, 7, 3, 1};
     int a2[] = {11, 8, 6, 5, 4, 2, 0};
@@ -48,7 +47,6 @@ int main(int, char**)
     assert((c1 == std::list<int, min_allocator<int>>(a3, a3+sizeof(a3)/sizeof(a3[0]))));
     assert(c2.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove.pass.cpp
index b773b6fb4b7..bbc6c6c8281 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove.pass.cpp
@@ -87,7 +87,6 @@ int main(int, char**) {
 #endif
     assert(c == List(a2, a2 + 3, Alloc::create()));
   }
-#if TEST_STD_VER >= 2011
   {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
@@ -99,7 +98,6 @@ int main(int, char**) {
 #endif
     assert((c == std::list<int, min_allocator<int>>(a2, a2 + 3)));
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
index eb19069708a..21fa7c7b27c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
@@ -84,7 +84,6 @@ int main(int, char**)
     }
     }
 
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {3, 4};
@@ -98,7 +97,6 @@ int main(int, char**)
     assert((c == std::list<int, min_allocator<int>>(a2, a2+2)));
     assert(cp.count() == 4);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/reverse.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
index 6ee915f14bb..fde66fefec5 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
@@ -25,7 +25,6 @@ int main(int, char**)
     c1.reverse();
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
     }
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
     int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
@@ -33,7 +32,6 @@ int main(int, char**)
     c1.reverse();
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort.pass.cpp
index 30c1dcca453..d170dc231a7 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort.pass.cpp
@@ -70,7 +70,6 @@ int main(int, char**)
     c1.sort();
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
     }
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
     int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
@@ -78,7 +77,6 @@ int main(int, char**)
     c1.sort();
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
-#endif
 
     for (int i = 0; i < 40; ++i)
         test_stable(i);
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
index 288f984f9ff..4fd7c82b6e3 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
@@ -112,7 +112,6 @@ int main(int, char**)
     }
 #endif
 
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
     int a2[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
@@ -120,7 +119,6 @@ int main(int, char**)
     c1.sort(std::greater<int>());
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
-#endif
 
     for (int i = 0; i < 40; ++i)
         test_stable(i);
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
index 7c3a38889a6..545608af7ce 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
@@ -399,7 +399,6 @@ int main(int, char**)
         ++i;
         assert(*i == 6);
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2;
@@ -779,7 +778,6 @@ int main(int, char**)
         ++i;
         assert(*i == 6);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
index 8ed6cc8af3d..f538ed3ff82 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
@@ -176,7 +176,6 @@ int main(int, char**)
         ++i;
         assert(*i == 2);
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+1);
@@ -333,7 +332,6 @@ int main(int, char**)
         ++i;
         assert(*i == 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
index 3dbc034f41a..dd633908b4c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
@@ -116,7 +116,6 @@ int main(int, char**)
         i = l2.begin();
         assert(*i == 4);
     }
-#if TEST_STD_VER >= 2011
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
@@ -213,7 +212,6 @@ int main(int, char**)
         i = l2.begin();
         assert(*i == 4);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique.pass.cpp
index 6cc043f9777..c895a366511 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
 #endif
     assert(c == std::list<int>(a2, a2+4));
     }
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
@@ -45,7 +44,6 @@ int main(int, char**)
 #endif
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
index 71f0195ada4..5a69f17d016 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     }
     }
 
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
@@ -77,7 +76,6 @@ int main(int, char**)
 #endif
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/list.special/swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/list.special/swap.pass.cpp
index 8ffcad22280..503e2a7d12d 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/list.special/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/list.special/swap.pass.cpp
@@ -83,7 +83,6 @@ int main(int, char**)
         assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A(1));
     }
-#if TEST_STD_VER >= 2011
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
@@ -136,7 +135,6 @@ int main(int, char**)
         assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/list/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/list/types.pass.cpp
index 4d2c1e92fe4..a804fa1d6bf 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/list/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/list/types.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 
-#if TEST_STD_VER >= 2011
     {
     typedef std::list<int, min_allocator<int>> C;
     static_assert((std::is_same<C::value_type, int>::value), "");
@@ -65,7 +64,6 @@ int main(int, char**)
     static_assert((std::is_same<typename C::difference_type,
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
index e93d513efb4..95905f8a796 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<bool>(5));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
         std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
@@ -40,7 +39,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<bool>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/capacity.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/capacity.pass.cpp
index 8d9537a6317..8015bb5331a 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/capacity.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/capacity.pass.cpp
@@ -29,7 +29,6 @@ int main(int, char**)
         v.push_back(0);
         assert(v.capacity() >= 101);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v;
         assert(v.capacity() == 0);
@@ -40,7 +39,6 @@ int main(int, char**)
         v.push_back(0);
         assert(v.capacity() >= 101);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_default.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
index b9bac65f205..c47a49bde7b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
@@ -29,19 +29,17 @@ test0()
 {
 #if TEST_STD_VER > 2014
     LIBCPP_STATIC_ASSERT((noexcept(C{})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     LIBCPP_STATIC_ASSERT((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
     LIBCPP_ASSERT(c.__invariants());
     assert(c.empty());
     assert(c.get_allocator() == typename C::allocator_type());
-#if TEST_STD_VER >= 2011
     C c1 = {};
     LIBCPP_ASSERT(c1.__invariants());
     assert(c1.empty());
     assert(c1.get_allocator() == typename C::allocator_type());
-#endif
 }
 
 template <class C>
@@ -50,7 +48,7 @@ test1(const typename C::allocator_type& a)
 {
 #if TEST_STD_VER > 2014
     LIBCPP_STATIC_ASSERT((noexcept(C{typename C::allocator_type{}})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     LIBCPP_STATIC_ASSERT((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
@@ -65,7 +63,6 @@ int main(int, char**)
     test0<std::vector<bool> >();
     test1<std::vector<bool, test_allocator<bool> > >(test_allocator<bool>(3));
     }
-#if TEST_STD_VER >= 2011
     {
     test0<std::vector<bool, min_allocator<bool>> >();
     test1<std::vector<bool, min_allocator<bool> > >(min_allocator<bool>());
@@ -74,7 +71,6 @@ int main(int, char**)
     test0<std::vector<bool, explicit_allocator<bool>> >();
     test1<std::vector<bool, explicit_allocator<bool> > >(explicit_allocator<bool>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
index 6eb72d58969..fce3e7f09a8 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
@@ -39,13 +39,11 @@ int main(int, char**)
     test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
     test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
     test<std::vector<bool> >(a, an);
-#if TEST_STD_VER >= 2011
     test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(a, an);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
index b2e01993b12..78f7c26c90a 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
     test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
     test<std::vector<bool> >(a, an, alloc);
     }
-#if TEST_STD_VER >= 2011
     {
     min_allocator<bool> alloc;
     test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an), alloc);
@@ -52,7 +51,6 @@ int main(int, char**)
     test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
     test<std::vector<bool, min_allocator<bool>> >(a, an, alloc);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
index 5758702bfe8..6eb8277d68d 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
@@ -59,10 +59,8 @@ test(typename C::size_type n)
 int main(int, char**)
 {
     test<std::vector<bool> >(50);
-#if TEST_STD_VER >= 2011
     test<std::vector<bool, min_allocator<bool>> >(50);
     test2<std::vector<bool, test_allocator<bool>> >( 100, test_allocator<bool>(23));
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
index 7dffb1d086e..ed132e2c533 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
@@ -31,9 +31,7 @@ test(typename C::size_type n, const typename C::value_type& x)
 int main(int, char**)
 {
     test<std::vector<bool> >(50, true);
-#if TEST_STD_VER >= 2011
     test<std::vector<bool, min_allocator<bool>> >(50, true);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
index 10410be77ec..248c573d1f6 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
@@ -33,9 +33,7 @@ test(typename C::size_type n, const typename C::value_type& x,
 int main(int, char**)
 {
     test<std::vector<bool> >(50, true, std::allocator<bool>());
-#if TEST_STD_VER >= 2011
     test<std::vector<bool, min_allocator<bool>> >(50, true, min_allocator<bool>());
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy.pass.cpp
index 757b7e657ac..dc8dea889d0 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy.pass.cpp
@@ -42,7 +42,6 @@ int main(int, char**)
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, other_allocator<bool> > v(3, true, other_allocator<bool>(5));
         std::vector<bool, other_allocator<bool> > v2 = v;
@@ -60,7 +59,6 @@ int main(int, char**)
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
index f5f89110fec..b606844d166 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<bool>(3));
     }
-#if TEST_STD_VER >= 2011
     {
         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]);
@@ -59,7 +58,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<bool>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/empty.pass.cpp
index 25ea7115e08..fc6a116b08b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::vector<bool, min_allocator<bool>> C;
     C c;
@@ -41,7 +40,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
index 0291df24e04..0906b081f85 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
     std::vector<bool, min_allocator<bool>>::const_iterator i = l1.begin();
@@ -61,7 +60,6 @@ int main(int, char**)
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
index 0a97f7ea492..1f135a789ed 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
         std::vector<bool, min_allocator<bool>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
@@ -81,7 +80,6 @@ int main(int, char**)
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
index fc3461d06fa..93199880106 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
@@ -91,7 +91,6 @@ int main(int, char**)
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v(100);
         bool a[] = {1, 0, 0, 1, 1};
@@ -124,7 +123,6 @@ int main(int, char**)
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
index 49c50146948..880e40b69d0 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
@@ -64,7 +64,6 @@ int main(int, char**)
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
@@ -78,7 +77,6 @@ int main(int, char**)
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
index efea6b656d6..a87768f353b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
@@ -61,7 +61,6 @@ int main(int, char**)
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 1);
@@ -74,7 +73,6 @@ int main(int, char**)
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp
index b0f7c51931d..992eeab2fbb 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp
@@ -58,7 +58,6 @@ int main(int, char**)
         C::iterator i;
         C::const_iterator j;
     }
-#if TEST_STD_VER >= 2011
     {
         typedef bool T;
         typedef std::vector<T, min_allocator<T>> C;
@@ -93,7 +92,6 @@ int main(int, char**)
         C::iterator i;
         C::const_iterator j;
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         std::vector<bool>::iterator ii1{}, ii2{};
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/push_back.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/push_back.pass.cpp
index a2ac589a96a..a9bbfdd7ebd 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/push_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/push_back.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
                 assert(c[j] == a[j]);
         }
     }
-#if TEST_STD_VER >= 2011
     {
         bool a[] = {0, 1, 1, 0, 1, 0, 0};
         const unsigned N = sizeof(a)/sizeof(a[0]);
@@ -45,7 +44,6 @@ int main(int, char**)
                 assert(c[j] == a[j]);
         }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
index 9ab9e03cf11..a33ec65cbfa 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
@@ -26,9 +26,7 @@ int main(int, char**)
     std::vector<bool>::reference r1 = v[0];
     std::vector<bool>::reference r2 = v[3];
 
-#if TEST_STD_VER >= 2011
     static_assert((noexcept(v.swap(r1,r2))), "");
-#endif
 
     assert(!r1);
     assert( r2);
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reserve.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reserve.pass.cpp
index b672802e16b..5666281da2b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reserve.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/reserve.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
         assert(v.size() == 100);
         assert(v.capacity() >= 150);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v;
         v.reserve(10);
@@ -50,7 +49,6 @@ int main(int, char**)
         assert(v.size() == 100);
         assert(v.capacity() >= 150);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
index 7821df1c795..a9b28b228f9 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         assert(v.size() == 300);
         assert(v.capacity() >= 400);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v(100);
         v.resize(50);
@@ -46,7 +45,6 @@ int main(int, char**)
         assert(v.size() == 300);
         assert(v.capacity() >= 400);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
index f0b07a426d1..bc81e5be68e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
         for (unsigned i = 50; i < 200; ++i)
             assert(v[i] == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v(100);
         v.resize(50, 1);
@@ -48,7 +47,6 @@ int main(int, char**)
         for (unsigned i = 50; i < 200; ++i)
             assert(v[i] == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
index ea5d3527bae..ca5b4b10a2f 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
@@ -26,7 +26,6 @@ int main(int, char**)
         assert(v.capacity() >= 101);
         assert(v.size() >= 101);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v(100);
         v.push_back(1);
@@ -34,7 +33,6 @@ int main(int, char**)
         assert(v.capacity() >= 101);
         assert(v.size() >= 101);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/size.pass.cpp
index ba2ddee106c..b4cd2cfeedb 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::vector<bool, min_allocator<bool>> C;
     C c;
@@ -57,7 +56,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/swap.pass.cpp
index 8062326104d..c634a3c4328 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/swap.pass.cpp
@@ -62,7 +62,6 @@ int main(int, char**)
         assert(v[0] == false);
         assert(v[1] == true);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<bool, min_allocator<bool>> v1(100);
         std::vector<bool, min_allocator<bool>> v2(200);
@@ -94,7 +93,6 @@ int main(int, char**)
         assert(v[0] == false);
         assert(v[1] == true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/types.pass.cpp
index e6bef0d22bc..d61a165842c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/types.pass.cpp
@@ -74,9 +74,7 @@ int main(int, char**)
     test<std::allocator<bool> >();
     static_assert((std::is_same<std::vector<bool>::allocator_type,
                                 std::allocator<bool> >::value), "");
-#if TEST_STD_VER >= 2011
     test<min_allocator<bool> >();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
index 076d6e82963..d54ed6e7c40 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
@@ -40,14 +40,12 @@ int main(int, char**)
     H h;
     assert(h(vb) != 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::vector<bool, min_allocator<bool>> T;
     typedef std::hash<T> H;
 #if TEST_STD_VER <= 2014
     static_assert((std::is_same<H::argument_type, T>::value), "" );
     static_assert((std::is_same<H::result_type, std::size_t>::value), "" );
-#endif
     ASSERT_NOEXCEPT(H()(T()));
     bool ba[] = {true, false, true, true, false};
     T vb(std::begin(ba), std::end(ba));
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/access.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/access.pass.cpp
index f0ed7ee3512..0013c15ab3e 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/access.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/access.pass.cpp
@@ -76,7 +76,6 @@ int main(int, char**)
         assert(c.front() == N);
         assert(c.back() == N + 9);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::vector<int, min_allocator<int>> C;
         const int N = 34;
@@ -115,7 +114,6 @@ int main(int, char**)
         assert(c.front() == N);
         assert(c.back() == N + 9);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/contiguous.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/contiguous.pass.cpp
index 2084b894f07..b410a4336bb 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/contiguous.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/contiguous.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
     test_contiguous(C(A(3)));
     test_contiguous(C(7, 9.0, A(5)));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef double T;
     typedef min_allocator<T> A;
@@ -48,7 +47,6 @@ int main(int, char**)
     test_contiguous(C(A{}));
     test_contiguous(C(9, 11.0, A{}));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/iterators.pass.cpp
index 8b95ad94fae..b199db4de87 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/iterators.pass.cpp
@@ -79,7 +79,6 @@ int main(int, char**)
         (void) i;
         (void) j;
     }
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::vector<T, min_allocator<T>> C;
@@ -138,7 +137,6 @@ int main(int, char**)
         C::const_iterator j = i;
         assert(j->first == 3);
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::vector<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/types.pass.cpp
index e7d8a21f3b8..36f0de3cccc 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/types.pass.cpp
@@ -86,7 +86,6 @@ int main(int, char**)
     test<Copyable, test_allocator<Copyable> >();
     static_assert((std::is_same<std::vector<char>::allocator_type,
                                 std::allocator<char> >::value), "");
-#if TEST_STD_VER >= 2011
     {
 
     typedef std::vector<int, min_allocator<int> > C;
@@ -104,7 +103,6 @@ int main(int, char**)
 //     static_assert((std::is_same<typename C::difference_type,
 //         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
index fad5d217a28..4a9ccbee926 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
@@ -31,7 +31,6 @@ int main(int, char**)
         assert(v.capacity() > 101);
         assert(is_contiguous_container_asan_correct(v));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v;
         assert(v.capacity() == 0);
@@ -44,7 +43,6 @@ int main(int, char**)
         assert(v.capacity() > 101);
         assert(is_contiguous_container_asan_correct(v));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
index 14058659857..e8138f5afdd 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::vector<int, min_allocator<int>> C;
     C c;
@@ -41,7 +40,6 @@ int main(int, char**)
     c.clear();
     assert(c.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
index 988f074ebdf..ca45b2f6f9b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(v.capacity() == 150);
         assert(is_contiguous_container_asan_correct(v));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v;
         v.reserve(10);
@@ -66,7 +65,6 @@ int main(int, char**)
         assert(v.capacity() == 150);
         assert(is_contiguous_container_asan_correct(v));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
index 52d628fcab3..8e19f0e1eee 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<MoveOnly> v(100);
         v.resize(50);
@@ -79,7 +78,6 @@ int main(int, char**)
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
index bdcfcf64f16..496250ed830 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v(100);
         v.resize(50, 1);
@@ -73,7 +72,6 @@ int main(int, char**)
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
index 0880fc55a9c..d6c77e8b204 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v(100);
         v.push_back(1);
@@ -58,7 +57,6 @@ int main(int, char**)
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
index ffa0991f2ae..96f3527507c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::vector<int, min_allocator<int>> C;
     C c;
@@ -57,7 +56,6 @@ int main(int, char**)
     c.erase(c.begin());
     assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
index 6cce3750b85..0e6cc6d0732 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         assert(v2.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v2));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v1(100);
         std::vector<int, min_allocator<int>> v2(200);
@@ -46,7 +45,6 @@ int main(int, char**)
         assert(v2.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
index 51f2172bde2..fc4a7579edf 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::vector<int, min_allocator<int> > l2(l, min_allocator<int>());
@@ -40,7 +39,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
index fe486c99cc1..5e38d32d892 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
@@ -17,14 +17,11 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 #include "test_iterators.h"
-#if TEST_STD_VER >= 2011
 #include "emplace_constructible.h"
 #include "container_test_types.h"
-#endif
 
 
 void test_emplaceable_concept() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -63,7 +60,6 @@ void test_emplaceable_concept() {
       assert(v[2].value == 42);
     }
   }
-#endif
 }
 
 
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
index 51499769fde..e148701791b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
     test(d2);
     }
 
-#if TEST_STD_VER >= 2011
     {
     typedef std::vector<int, min_allocator<int>> V;
     V d1;
@@ -49,7 +48,6 @@ int main(int, char**)
     test(d1);
     test(d2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
index 5919fba5780..0f6bf9462e5 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
@@ -27,7 +27,7 @@ test0()
 {
 #if TEST_STD_VER > 2014
     static_assert((noexcept(C{})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
@@ -35,13 +35,11 @@ test0()
     assert(c.empty());
     assert(c.get_allocator() == typename C::allocator_type());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
-#if TEST_STD_VER >= 2011
     C c1 = {};
     LIBCPP_ASSERT(c1.__invariants());
     assert(c1.empty());
     assert(c1.get_allocator() == typename C::allocator_type());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c1));
-#endif
 }
 
 template <class C>
@@ -50,7 +48,7 @@ test1(const typename C::allocator_type& a)
 {
 #if TEST_STD_VER > 2014
     static_assert((noexcept(C{typename C::allocator_type{}})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
@@ -73,7 +71,6 @@ int main(int, char**)
         std::vector<int, limited_allocator<int, 10> > v;
         assert(v.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     test0<std::vector<int, min_allocator<int>> >();
     test0<std::vector<NotConstructible, min_allocator<NotConstructible>> >();
@@ -97,7 +94,6 @@ int main(int, char**)
         std::vector<int, explicit_allocator<int> > v;
         assert(v.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index 945ab810b46..82edc2832a0 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -19,10 +19,8 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
-#if TEST_STD_VER >= 2011
 #include "emplace_constructible.h"
 #include "container_test_types.h"
-#endif
 
 template <class C, class Iterator>
 void test(Iterator first, Iterator last) {
@@ -60,7 +58,6 @@ static void basic_test_cases() {
       random_access_iterator<const int*>(a),
       random_access_iterator<const int*>(an));
   test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
-#if TEST_STD_VER >= 2011
   test<std::vector<int, min_allocator<int> > >(cpp17_input_iterator<const int*>(a),
                                                cpp17_input_iterator<const int*>(an));
   test<std::vector<int, min_allocator<int> > >(
@@ -72,11 +69,9 @@ static void basic_test_cases() {
       random_access_iterator<const int*>(a),
       random_access_iterator<const int*>(an));
   test<std::vector<int> >(a, an);
-#endif
 }
 
 void emplaceable_concept_tests() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -111,11 +106,9 @@ void emplaceable_concept_tests() {
       assert(v[2].value == 42);
     }
   }
-#endif
 }
 
 void test_ctor_under_alloc() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -142,7 +135,6 @@ void test_ctor_under_alloc() {
       //C v(It(arr2), It(std::end(arr2)), a);
     }
   }
-#endif
 }
 
 // In C++03, you can't instantiate a template with a local type.
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
index d89d1a1b607..003b85bedab 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -20,10 +20,8 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
-#if TEST_STD_VER >= 2011
 #include "emplace_constructible.h"
 #include "container_test_types.h"
-#endif
 
 template <class C, class Iterator, class A>
 void test(Iterator first, Iterator last, const A& a) {
@@ -36,7 +34,6 @@ void test(Iterator first, Iterator last, const A& a) {
     assert(*i == *first);
 }
 
-#if TEST_STD_VER >= 2011
 
 template <class T>
 struct implicit_conv_allocator : min_allocator<T> {
@@ -47,7 +44,6 @@ struct implicit_conv_allocator : min_allocator<T> {
   implicit_conv_allocator(implicit_conv_allocator<U>) {}
 };
 
-#endif
 
 void basic_tests() {
   {
@@ -64,7 +60,6 @@ void basic_tests() {
                             random_access_iterator<const int*>(an), alloc);
     test<std::vector<int> >(a, an, alloc);
   }
-#if TEST_STD_VER >= 2011
   {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
     int* an = a + sizeof(a) / sizeof(a[0]);
@@ -83,11 +78,9 @@ void basic_tests() {
     test<std::vector<int, min_allocator<int> > >(a, an, alloc);
     test<std::vector<int, implicit_conv_allocator<int> > >(a, an, nullptr);
   }
-#endif
 }
 
 void emplaceable_concept_tests() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -124,11 +117,9 @@ void emplaceable_concept_tests() {
       assert(v[2].value == 42);
     }
   }
-#endif
 }
 
 void test_ctor_under_alloc() {
-#if TEST_STD_VER >= 2011
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};
   {
@@ -159,7 +150,6 @@ void test_ctor_under_alloc() {
       //C v(It(arr2), It(std::end(arr2)), a);
     }
   }
-#endif
 }
 
 int main(int, char**) {
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
index b158bd1dfcf..d1afe0078f8 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
@@ -46,10 +46,8 @@ test1(typename C::size_type n)
     assert(c.size() == n);
     assert(c.get_allocator() == typename C::allocator_type());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
-#if TEST_STD_VER >= 2011
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == typename C::value_type());
-#endif
 }
 
 template <class C>
@@ -65,12 +63,10 @@ int main(int, char**)
     test<std::vector<int> >(50);
     test<std::vector<DefaultOnly> >(500);
     assert(DefaultOnly::count == 0);
-#if TEST_STD_VER >= 2011
     test<std::vector<int, min_allocator<int>> >(50);
     test<std::vector<DefaultOnly, min_allocator<DefaultOnly>> >(500);
     test2<std::vector<DefaultOnly, test_allocator<DefaultOnly>> >( 100, test_allocator<DefaultOnly>(23));
     assert(DefaultOnly::count == 0);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
index c0682451f9e..e0078026d6a 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
@@ -35,9 +35,7 @@ int main(int, char**)
     test<std::vector<int> >(50, 3);
     // Add 1 for implementations that dynamically allocate a container proxy.
     test<std::vector<int, limited_allocator<int, 50 + 1> > >(50, 5);
-#if TEST_STD_VER >= 2011
     test<std::vector<int, min_allocator<int>> >(50, 3);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
index b13da4aff9e..4c203494fd1 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
@@ -34,9 +34,7 @@ test(typename C::size_type n, const typename C::value_type& x,
 int main(int, char**)
 {
     test<std::vector<int> >(50, 3, std::allocator<int>());
-#if TEST_STD_VER >= 2011
     test<std::vector<int, min_allocator<int>> >(50, 3, min_allocator<int>());
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
index fe20d5e89c5..326162f5f97 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(is_contiguous_container_asan_correct(v));
         assert(is_contiguous_container_asan_correct(v2));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, other_allocator<int> > v(3, 2, other_allocator<int>(5));
         std::vector<int, other_allocator<int> > v2 = v;
@@ -73,7 +72,6 @@ int main(int, char**)
         assert(is_contiguous_container_asan_correct(v));
         assert(is_contiguous_container_asan_correct(v2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
index 2c433b1e5a6..9ea44a12fbb 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(3));
     }
-#if TEST_STD_VER >= 2011
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
         int* an = a + sizeof(a)/sizeof(a[0]);
@@ -61,7 +60,6 @@ int main(int, char**)
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data.pass.cpp
index e76d53f7f1c..487b75c5ea6 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
         assert(v.data() == std::addressof(v.front()));
         assert(is_contiguous_container_asan_correct(v));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v;
         assert(v.data() == 0);
@@ -59,7 +58,6 @@ int main(int, char**)
         assert(v.data() == std::addressof(v.front()));
         assert(is_contiguous_container_asan_correct(v));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
index f619895f97a..18285ca441c 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
         assert(v.data() == std::addressof(v.front()));
         assert(is_contiguous_container_asan_correct(v));
     }
-#if TEST_STD_VER >= 2011
     {
         const std::vector<int, min_allocator<int>> v;
         assert(v.data() == 0);
@@ -59,7 +58,6 @@ int main(int, char**)
         assert(v.data() == std::addressof(v.front()));
         assert(is_contiguous_container_asan_correct(v));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
index 8e4bda17ceb..b31a59f5722 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
@@ -28,7 +28,6 @@ int main(int, char**)
     LIBCPP_ASSERT(c.__invariants());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     }
-#if TEST_STD_VER >= 2011
     {
     int a[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> c(a, a+3);
@@ -38,7 +37,6 @@ int main(int, char**)
     LIBCPP_ASSERT(c.__invariants());
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
index 741bf72da91..0ec2f43753f 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
@@ -60,7 +60,6 @@ int main(int, char**)
     assert(distance(l1.begin(), l1.end()) == 0);
     assert(is_contiguous_container_asan_correct(l1));
     }
-#if TEST_STD_VER >= 2011
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
@@ -86,7 +85,6 @@ int main(int, char**)
     assert(distance(l1.begin(), l1.end()) == 0);
     assert(is_contiguous_container_asan_correct(l1));
     }
-#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
 // Test for LWG2853:
 // Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
index 9d974de92b3..d3de135b0a5 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
@@ -87,7 +87,6 @@ int main(int, char**)
         assert(is_contiguous_container_asan_correct(outer[0]));
         assert(is_contiguous_container_asan_correct(outer[1]));
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
@@ -139,7 +138,6 @@ int main(int, char**)
         assert(is_contiguous_container_asan_correct(outer[0]));
         assert(is_contiguous_container_asan_correct(outer[1]));
     }
-#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
 // Test for LWG2853:
 // Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
index a578907b641..3fd204b2df8 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
@@ -133,7 +133,6 @@ int main(int, char**)
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::vector<int, min_allocator<int> > V;
         V v(100);
@@ -170,7 +169,6 @@ int main(int, char**)
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
index 8cc55b161c6..a8ee164ae6b 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
@@ -81,7 +81,6 @@ int main(int, char**)
         for (++j; j < 105; ++j)
             assert(v[j] == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
@@ -110,7 +109,6 @@ int main(int, char**)
         for (++j; j < 105; ++j)
             assert(v[j] == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
index ede3e6cce60..46b94b653e4 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
@@ -78,7 +78,6 @@ int main(int, char**)
         for (++j; j < 101; ++j)
             assert(v[j] == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 1);
@@ -92,7 +91,6 @@ int main(int, char**)
         for (++j; j < 101; ++j)
             assert(v[j] == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
index 2ce22399765..22431d7cc04 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
@@ -28,7 +28,6 @@ int main(int, char**)
         assert(c.size() == 0);
 
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> c;
         c.push_back(1);
@@ -36,7 +35,6 @@ int main(int, char**)
         c.pop_back();
         assert(c.size() == 0);
     }
-#endif
 
     { // LWG 526
         int arr[] = {0, 1, 2, 3, 4};
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
index 41dab45c971..ac8909d8a60 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
@@ -79,7 +79,6 @@ int main(int, char**)
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
     }
-#if TEST_STD_VER >= 2011
     {
         std::vector<int, min_allocator<int>> c;
         c.push_back(0);
@@ -108,7 +107,6 @@ int main(int, char**)
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.special/swap.pass.cpp b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
index 787b7fda4d5..7eda01816db 100644
--- a/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
@@ -105,7 +105,6 @@ int main(int, char**)
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
-#if TEST_STD_VER >= 2011
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
@@ -178,7 +177,6 @@ int main(int, char**)
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/iterator_difference_type.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/iterator_difference_type.pass.cpp
index 38ebaace2bf..ef75bdf9264 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/iterator_difference_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/iterator_difference_type.pass.cpp
@@ -85,14 +85,12 @@ int main(int, char**) {
     typedef std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
     testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::pair<const int, int> ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
     testUnorderedMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
   }
-#endif
   {
     typedef std::unordered_multimap<int, int> Map;
     typedef std::pair<const int, int> ValueTp;
@@ -104,14 +102,12 @@ int main(int, char**) {
     typedef std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
     testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::pair<const int, int> ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, Alloc> Map;
     testUnorderedMap<Map, ValueTp, min_pointer<ValueTp>, min_pointer<const ValueTp>>();
   }
-#endif
   {
     typedef int ValueTp;
     typedef std::unordered_set<ValueTp> Set;
@@ -123,14 +119,12 @@ int main(int, char**) {
     typedef std::unordered_set<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
     testUnorderedSet<Set, ValueTp, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef int ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::unordered_set<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
     testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
-#endif
   {
     typedef int ValueTp;
     typedef std::unordered_multiset<ValueTp> Set;
@@ -142,14 +136,12 @@ int main(int, char**) {
     typedef std::unordered_multiset<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
     testUnorderedSet<Set, ValueTp, ValueTp const*>();
   }
-#if TEST_STD_VER >= 2011
   {
     typedef int ValueTp;
     typedef min_allocator<ValueTp> Alloc;
     typedef std::unordered_multiset<ValueTp, std::hash<ValueTp>, std::equal_to<ValueTp>, Alloc> Set;
     testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket.pass.cpp
index d734107ef4d..578b947c8e3 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#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;
@@ -65,7 +64,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_map<int, std::string> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_count.pass.cpp
index b26e3f7c260..493a6e398e6 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_count.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
-#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;
@@ -70,7 +69,6 @@ int main(int, char**)
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_size.pass.cpp
index 4d97c4b5f4d..4650d501cfb 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/bucket_size.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(3) == 1);
         LIBCPP_ASSERT(c.bucket_size(4) == 1);
     }
-#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;
@@ -69,7 +68,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(3) == 1);
         LIBCPP_ASSERT(c.bucket_size(4) == 1);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_map<int, std::string> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/count.pass.cpp
index c0dc25c9720..3d756936c58 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/count.pass.cpp
@@ -41,7 +41,6 @@ int main(int, char**)
         assert(c.count(30) == 1);
         assert(c.count(5) == 0);
     }
-#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;
@@ -61,7 +60,6 @@ int main(int, char**)
         assert(c.count(30) == 1);
         assert(c.count(5) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/empty.pass.cpp
index 1bf9b3e5174..a3abfcf4370 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_map<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -41,7 +40,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/eq.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/eq.pass.cpp
index be8e47d8814..fcbe8795cef 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/eq.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/eq.pass.cpp
@@ -91,7 +91,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#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;
@@ -159,7 +158,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
index 691bac7dc9a..ed5a0e11469 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
     }
-#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;
@@ -71,7 +70,6 @@ int main(int, char**)
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
index 89256309cae..c21e5c93549 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
     }
-#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;
@@ -71,7 +70,6 @@ int main(int, char**)
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_const.pass.cpp
index c8f477dede2..871479fb95d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_const.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#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;
@@ -67,7 +66,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_non_const.pass.cpp
index 2f26b4ee3ce..62df8901170 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/find_non_const.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.end());
     }
-#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;
@@ -67,7 +66,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp
index aee8439d7f7..e01dbcfde16 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#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;
@@ -108,7 +107,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::unordered_map<int,double> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/load_factor.pass.cpp
index 53cbac6dc05..a9dc85e9272 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/load_factor.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#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;
@@ -72,7 +71,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/local_iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/local_iterators.pass.cpp
index b12c8641104..ea78ca2faa1 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/local_iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/local_iterators.pass.cpp
@@ -220,7 +220,6 @@ int main(int, char**)
         assert(i->first == 4);
         assert(i->second == "four");
     }
-#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;
@@ -417,7 +416,6 @@ int main(int, char**)
         assert(i->first == 4);
         assert(i->second == "four");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
index 595c7ae2afc..ef1ea666f4f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#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;
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
index a2e7a3f529b..5dc50a73cc5 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
@@ -41,7 +41,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#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;
@@ -56,7 +55,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_map<int, std::string> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/rehash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/rehash.pass.cpp
index efecd49a309..fc9c73eaaab 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/rehash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/rehash.pass.cpp
@@ -68,7 +68,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#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;
@@ -99,7 +98,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/reserve.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/reserve.pass.cpp
index 059ea549b91..e07a14eb566 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/reserve.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/reserve.pass.cpp
@@ -74,7 +74,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#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;
@@ -102,7 +101,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#endif
     reserve_invariant(20);
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/size.pass.cpp
index d5adf4c20ac..c3e14ff4d2c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_map<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -57,7 +56,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
index 1073e095ff7..29b67a9f8f4 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
@@ -387,7 +387,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -567,7 +566,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/types.pass.cpp
index 11948c7702e..50d487fbbab 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/types.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<char, short, std::hash<char>, std::equal_to<char>,
                             min_allocator<std::pair<const char, short>>> C;
@@ -68,7 +67,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
index 2703b835a25..a19340a0000 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -125,7 +124,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
index 740aa0ed240..98902e4acf4 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
@@ -139,7 +139,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
@@ -185,7 +184,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
index f9ae47b6f8e..6ce44dea156 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<int>,
@@ -148,7 +147,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
index 6776ac4c27e..f3719baec2b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<int>,
@@ -148,7 +147,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
index fb1f7249e5d..8bcb696dd0c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -108,7 +107,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter.pass.cpp
index 846fe77ee03..5f92fb4af8b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter.pass.cpp
@@ -66,7 +66,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<int>,
@@ -168,7 +167,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size.pass.cpp
index fbc9c51fdcf..2c131e85efd 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<int>,
@@ -103,7 +102,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash.pass.cpp
index 365629387b3..ea20c34c223 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<int>,
@@ -106,7 +105,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal.pass.cpp
index c5c1b6eb7c9..2de634e104a 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal.pass.cpp
@@ -70,7 +70,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<int>,
@@ -108,7 +107,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
index 63d52a2d772..856b5a6d60f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
@@ -72,7 +72,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<int>,
@@ -149,7 +148,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
index 3f1fff5fd70..76ba487f806 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
@@ -65,7 +64,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
index 9101e886bb8..b482cd85988 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -65,7 +64,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
index b8f3fa3952d..8bf89333826 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -70,7 +69,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
index babdcc3b38d..f0524dbcd9e 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -72,7 +71,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
index 986b5aca1d2..d2ab0624829 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -96,7 +95,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
index e120491c0fe..91d88d474c3 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
@@ -81,7 +81,6 @@ int main(int, char**)
         assert(c.size() == 4);
 #endif
     }
-#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;
@@ -109,7 +108,6 @@ int main(int, char**)
         {
         }
         assert(c.size() == 4);
-#endif
     }
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
index d47c2f14a4b..e6de8577beb 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
@@ -24,9 +24,7 @@
 #include "min_allocator.h"
 #include "count_new.h"
 
-#if TEST_STD_VER >= 2011
 #include "container_test_types.h"
-#endif
 
 int main(int, char**)
 {
@@ -50,7 +48,6 @@ int main(int, char**)
         assert(c.size() == 5);
         assert(c.at(11) == "eleven");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<MoveOnly, std::string> C;
         typedef std::pair<int, std::string> P;
@@ -158,7 +155,6 @@ int main(int, char**)
             }
         }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
index 67ea82731c6..63b1e13e50f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#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;
@@ -59,7 +58,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
index f788bdb026f..a9f83060e64 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
@@ -52,7 +52,6 @@ int main(int, char**)
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
-#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;
@@ -74,7 +73,6 @@ int main(int, char**)
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
index 8a0b4892ecd..66423fd0f16 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
@@ -21,7 +21,6 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
@@ -35,7 +34,6 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 
     return p == part.end();
 }
-#endif
 
 
 int main(int, char**)
@@ -96,7 +94,6 @@ int main(int, char**)
         assert(c.erase(3) == 0);
         assert(c.size() == 0);
     }
-#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;
@@ -173,7 +170,6 @@ int main(int, char**)
 
     assert (only_deletions (m, m2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
index f3fcbf38ac2..dcc1a79d4e6 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
@@ -58,7 +58,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#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;
@@ -95,7 +94,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
index 9b4173cbe54..a494802d2d8 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
@@ -71,13 +71,11 @@ int main(int, char**)
         typedef std::unordered_map<double, int> M;
         do_insert_cv_test<M>();
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> M;
         do_insert_cv_test<M>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
index 08b97c5e76c..8db04771727 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -60,14 +60,12 @@ void do_insert_hint_const_lvalue_test()
 int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_map<double, int> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
 
         do_insert_hint_const_lvalue_test<C>();
     }
-#endif
 #if _LIBCUDACXX_DEBUG >= 1
     {
         typedef std::unordered_map<double, int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
index 7df66685b26..4f46426adb1 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
-#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;
@@ -67,7 +66,6 @@ int main(int, char**)
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
index ba61ce68cf3..d23f73f7060 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
@@ -395,7 +395,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -575,7 +574,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket.pass.cpp
index c5af2eac90a..f135468917a 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -65,7 +64,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multimap<int, std::string> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
index c55a34abf6e..094d1bce449 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(5) == 0);
         LIBCPP_ASSERT(c.bucket_size(6) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -73,7 +72,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(5) == 0);
         LIBCPP_ASSERT(c.bucket_size(6) == 0);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multimap<int, std::string> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/count.pass.cpp
index b3d11d3e0b8..cce91ecd1ff 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/count.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.count(50) == 3);
         assert(c.count(5) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -67,7 +66,6 @@ int main(int, char**)
         assert(c.count(50) == 3);
         assert(c.count(5) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
index 6a086651b21..32d5defd145 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
@@ -36,7 +36,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_multimap<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
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
index a23d7a6661b..cf4828ea71d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/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_multimap<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
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
index 310a9ebcc70..112aa8df9c2 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/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_multimap<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
 
 }
 
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
index 68f2a1a120d..5b3f6a53a83 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/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_multimap<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
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/empty.pass.cpp
index 06418181667..e7a0e7ce662 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_multimap<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -41,7 +40,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/eq.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/eq.pass.cpp
index 8d37a4e95da..19883ea0499 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/eq.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/eq.pass.cpp
@@ -100,7 +100,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -177,7 +176,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
index b614b45c2fa..10af11ee848 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
@@ -61,7 +61,6 @@ int main(int, char**)
             ++r.first;
         }
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -100,7 +99,6 @@ int main(int, char**)
             ++r.first;
         }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
index 614601a08c5..5b74468634e 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
@@ -61,7 +61,6 @@ int main(int, char**)
             ++r.first;
         }
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -100,7 +99,6 @@ int main(int, char**)
             ++r.first;
         }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_const.pass.cpp
index b58507f50a9..b896730f48d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_const.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -67,7 +66,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
index c57d0e181b7..b17dc50acf5 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -67,7 +66,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp
index 6ff32fe1274..a08a62af72f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp
@@ -70,7 +70,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -114,7 +113,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::unordered_multimap<int,double> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
index d532334b135..08394f8917d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -72,7 +71,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
index c7f5a388856..7b74edeb506 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
@@ -341,7 +341,6 @@ int main(int, char**)
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -658,7 +657,6 @@ int main(int, char**)
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
index 15fc2c8a2c1..c729aff418a 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
index a287e9e7aa1..bf72ee374d7 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -55,7 +54,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multimap<int, std::string> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index 7e03d8935f4..0939ec01003 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -112,7 +112,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -143,7 +142,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/reserve.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/reserve.pass.cpp
index 1b3018e3797..24d19a47f00 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/reserve.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/reserve.pass.cpp
@@ -89,7 +89,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -117,7 +116,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#endif
     reserve_invariant(20);
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/size.pass.cpp
index 97521f219d0..c62f4c803a0 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_multimap<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
     M m;
@@ -57,7 +56,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
index d7705266fe0..4f24dc19e11 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -446,7 +446,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -654,7 +653,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/types.pass.cpp
index 40498389f0d..a10f020ba34 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/types.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<char, short, std::hash<char>, std::equal_to<char>,
                             min_allocator<std::pair<const char, short>>> C;
@@ -68,7 +67,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
index 7bd15a5698b..759f7fa1de7 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -124,7 +123,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
index c76ec034745..fda255d14e7 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -154,7 +154,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
@@ -207,7 +206,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
index a7984f487b3..79411fb2116 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -78,7 +78,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<int>,
@@ -171,7 +170,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
index 069d10abf9f..f0e2d1bd584 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -77,7 +77,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<int>,
@@ -170,7 +169,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
index d5815856375..fbe6064f188 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -108,7 +107,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter.pass.cpp
index cdb65419e9b..927a985fbf3 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter.pass.cpp
@@ -84,7 +84,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<int>,
@@ -242,7 +241,6 @@ int main(int, char**)
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size.pass.cpp
index 65a21adb068..c8aa3c1b42c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size.pass.cpp
@@ -86,7 +86,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<int>,
@@ -139,7 +138,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash.pass.cpp
index 2acf2989540..33b60ca2e77 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash.pass.cpp
@@ -88,7 +88,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<int>,
@@ -142,7 +141,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal.pass.cpp
index 201006b50c4..1c6b9009469 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal.pass.cpp
@@ -89,7 +89,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<int>,
@@ -144,7 +143,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
index 690bfdf756c..6fa172ddea6 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
@@ -91,7 +91,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<int>,
@@ -203,7 +202,6 @@ int main(int, char**)
         assert(c.key_eq() == test_equal_to<int>(9));
         assert(c.get_allocator() == A{});
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
index 3184d2bb928..f223c3a9288 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
@@ -65,7 +64,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
index f093a5544b3..007b7b60f39 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -66,7 +65,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
index 002aa0f1f5c..47c249308a9 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -69,7 +68,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
index 0ca97214fe3..eec16d4130a 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -72,7 +71,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
index d327ea7bda8..2ae269abb3e 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
                                    test_hash<NotConstructible>,
@@ -96,7 +95,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
index 161df5bdef2..8e78955910c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -59,7 +58,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
index 88ead4f6154..88075c26e6b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
@@ -81,7 +81,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -129,7 +128,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
index 6d54846c7c4..8d2a53e4ded 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
@@ -24,7 +24,6 @@
 #include "../../../check_consecutive.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
@@ -38,7 +37,6 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 
     return p == part.end();
 }
-#endif
 
 int main(int, char**)
 {
@@ -186,7 +184,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -353,7 +350,6 @@ int main(int, char**)
 
     assert (only_deletions (m, m2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
index e6a87071eb8..bc7d9316a5b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
@@ -93,7 +93,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -162,7 +161,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
index 251fdb0fd0a..0f67028fe1a 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
@@ -55,13 +55,11 @@ void do_insert_const_lvalue_test()
 int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
         do_insert_const_lvalue_test<C>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
index eb69961d292..ecc9d6d477c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -60,13 +60,11 @@ void do_insert_const_lvalue_test()
 int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
         do_insert_const_lvalue_test<C>();
     }
-#endif
 #if _LIBCUDACXX_DEBUG >= 1
     {
         typedef std::unordered_multimap<double, int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
index f548566c28c..f06a00dbab8 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -68,7 +68,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
@@ -110,7 +109,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
index 79338d4f2a0..4162931ea31 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -418,7 +418,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -608,7 +607,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket.pass.cpp
index ad8f7766733..dd7de2a8a3f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -64,7 +63,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multiset<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
index 6777dad876b..922fd6aedca 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -69,7 +68,6 @@ int main(int, char**)
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
index be3c3319ad1..a78bda0054a 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(5) == 0);
         LIBCPP_ASSERT(c.bucket_size(6) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -72,7 +71,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(5) == 0);
         LIBCPP_ASSERT(c.bucket_size(6) == 0);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multiset<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/clear.pass.cpp
index 987783107be..3f1a53e4ab1 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/clear.pass.cpp
@@ -39,7 +39,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -58,7 +57,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/count.pass.cpp
index 781b048905a..2d6fbc819d7 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/count.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
         assert(c.count(50) == 3);
         assert(c.count(5) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -66,7 +65,6 @@ int main(int, char**)
         assert(c.count(50) == 3);
         assert(c.count(5) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
index f3646e1568d..303328b6425 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
@@ -35,7 +35,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -46,7 +45,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
index 8ef9a738c32..a1b9d75fab0 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -42,7 +41,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
index d11705296f7..d72c28dee3f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -44,7 +43,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#endif
 
 }
 
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
index 9b6fd270a65..6d1c0759148 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -42,7 +41,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/empty.pass.cpp
index dfe7ec40705..d25961131e5 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
     M m;
@@ -41,7 +40,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/eq.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/eq.pass.cpp
index 45fc7894d53..787fe701496 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/eq.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/eq.pass.cpp
@@ -99,7 +99,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -176,7 +175,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
index b725604a080..a53f5d0faaa 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
@@ -53,7 +53,6 @@ int main(int, char**)
         ++r.first;
         assert(*r.first == 50);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -86,7 +85,6 @@ int main(int, char**)
         ++r.first;
         assert(*r.first == 50);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
index b0aecd9520d..22276b0ffa7 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
@@ -53,7 +53,6 @@ int main(int, char**)
         ++r.first;
         assert(*r.first == 50);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -86,7 +85,6 @@ int main(int, char**)
         ++r.first;
         assert(*r.first == 50);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
index 128cb600254..c2b2d7078bf 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -82,7 +81,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
index e55ff95d303..e5cfef1035e 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
@@ -21,7 +21,6 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
@@ -35,7 +34,6 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 
     return p == part.end();
 }
-#endif
 
 int main(int, char**)
 {
@@ -95,7 +93,6 @@ int main(int, char**)
         assert(c.erase(3) == 0);
         assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -172,7 +169,6 @@ int main(int, char**)
 
     assert (only_deletions (m, m2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
index 608263af266..2d653c4776c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -91,7 +90,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_const.pass.cpp
index fdb6133f712..dcb11f1fc48 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_const.pass.cpp
@@ -42,7 +42,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -64,7 +63,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
index 88e613c0699..4597cb51b1e 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
@@ -42,7 +42,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -64,7 +63,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
index 96b5cbf5ba2..b4f1d4c6d55 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
@@ -50,13 +50,11 @@ void do_insert_const_lvalue_test()
 int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multiset<double> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<double, std::hash<double>,
             std::equal_to<double>, min_allocator<double>> C;
         do_insert_const_lvalue_test<C>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
index b93aadaef76..1ac4b49de30 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
@@ -55,13 +55,11 @@ void do_insert_hint_const_lvalue_test()
 int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_multiset<double> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<double, std::hash<double>,
             std::equal_to<double>, min_allocator<double>> C;
         do_insert_hint_const_lvalue_test<C>();
     }
-#endif
 #if _LIBCUDACXX_DEBUG >= 1
     {
         typedef std::unordered_multiset<double> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
index ba4e392edf4..1f0e4000105 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
         assert(c.size() == 4);
         assert(*r == 5.5);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<MoveOnly> C;
         typedef C::iterator R;
@@ -114,7 +113,6 @@ int main(int, char**)
         assert(c.size() == 4);
         assert(*r == 5);
     }
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
index d7770ba2730..90454e4a115 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -66,7 +65,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
index 1a8b4ed41e6..62f217b5a19 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.size() == 4);
         assert(*r == 5.5);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<MoveOnly> C;
         typedef C::iterator R;
@@ -110,7 +109,6 @@ int main(int, char**)
         assert(c.size() == 4);
         assert(*r == 5);
     }
-#endif  // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp
index f4b71d3836a..97852f5a664 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp
@@ -66,7 +66,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -107,7 +106,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::unordered_multiset<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
index 9bd70b4598e..44f4cd2f28b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -71,7 +70,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
index f160042b765..1b477d4cf86 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
@@ -259,7 +259,6 @@ int main(int, char**)
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -496,7 +495,6 @@ int main(int, char**)
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
index 19484f0b6ce..db6d029a12c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
@@ -27,14 +27,12 @@ int main(int, char**)
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
index 650ef58367c..0f4fae73e5e 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
@@ -39,7 +39,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -54,7 +53,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_multiset<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/rehash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/rehash.pass.cpp
index 6e30106b31e..fa2a737705f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/rehash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/rehash.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -98,7 +97,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/reserve.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/reserve.pass.cpp
index bd9847dfea8..6f90d0e39f2 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/reserve.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/reserve.pass.cpp
@@ -73,7 +73,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -101,7 +100,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#endif
     reserve_invariant(20);
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/size.pass.cpp
index aea3c43c14c..8494d24c55c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
     M m;
@@ -57,7 +56,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
index c02358f328d..e1293f505b8 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -386,7 +386,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -566,7 +565,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/types.pass.cpp
index 51578807357..149b0aff8c7 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/types.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<short, std::hash<short>,
                                   std::equal_to<short>, min_allocator<short>> C;
@@ -65,7 +64,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
index 4be2d465408..ba82da8b3bc 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -105,7 +104,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
index 92a1165fe39..9dc23dc8500 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -140,7 +140,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
@@ -186,7 +185,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
index d56282b2feb..65947ddc977 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -68,7 +68,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int,
                                    test_hash<int>,
@@ -145,7 +144,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
index d20db18477c..be35b1601f6 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -68,7 +68,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int,
                                    test_hash<int>,
@@ -107,7 +106,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
index f8d9647febb..640389b7349 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -104,7 +103,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter.pass.cpp
index aa426dfec66..3bbd0a6a2f6 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter.pass.cpp
@@ -62,7 +62,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int,
                                    test_hash<int>,
@@ -164,7 +163,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size.pass.cpp
index d903620852e..b68956ac68d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size.pass.cpp
@@ -64,7 +64,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int,
                                    test_hash<int>,
@@ -99,7 +98,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash.pass.cpp
index 480a0c94d4c..e80c12f9f09 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash.pass.cpp
@@ -66,7 +66,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int,
                                    test_hash<int>,
@@ -102,7 +101,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal.pass.cpp
index 8a95ba71788..e53c904aff0 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int,
                                    test_hash<int>,
@@ -104,7 +103,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
index 7d3bed4a319..e6e955a3c24 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<int,
                                    test_hash<int>,
@@ -107,7 +106,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
index 0ccfd90a7d6..2f9ff26bf37 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<std::hash<NotConstructible> >,
@@ -61,7 +60,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
index dfc0f429010..a2508441772 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -62,7 +61,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
index c2e08a0f5ec..f7b4f9af124 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -66,7 +65,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
index ca0e97597ad..7e0f2518d80 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -68,7 +67,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
index b6703644d93..4eae6a956be 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_multiset<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -70,7 +69,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
index f475bdc555b..f4f2ffc1c59 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -394,7 +394,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -574,7 +573,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket.pass.cpp
index 5f2dae31e52..b62120041a0 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -63,7 +62,6 @@ int main(int, char**)
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_set<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_count.pass.cpp
index 40c6ad491ae..3ac3898371b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_count.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         const C c;
@@ -67,7 +66,6 @@ int main(int, char**)
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_size.pass.cpp
index 1e30e1887c1..a6fe97b0b3d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/bucket_size.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(3) == 1);
         LIBCPP_ASSERT(c.bucket_size(4) == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -67,7 +66,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_size(3) == 1);
         LIBCPP_ASSERT(c.bucket_size(4) == 1);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_set<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/clear.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/clear.pass.cpp
index f37b7a78450..fb4b9e1cfac 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/clear.pass.cpp
@@ -39,7 +39,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -57,7 +56,6 @@ int main(int, char**)
         c.clear();
         assert(c.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/count.pass.cpp
index f7a4d03e8db..d255cae2bba 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/count.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
         assert(c.count(50) == 1);
         assert(c.count(5) == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -65,7 +64,6 @@ int main(int, char**)
         assert(c.count(50) == 1);
         assert(c.count(5) == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
index c7e4200df4d..8f54dfc7b21 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
@@ -35,7 +35,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -46,7 +45,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
index 27d06b36dc7..e63cc0523bb 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -42,7 +41,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
index 22af7016fb6..51a8811680b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -44,7 +43,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#endif
 
 }
 
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
index aa71ad49f61..58e46554145 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
 
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef int T;
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
@@ -43,7 +42,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/empty.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/empty.pass.cpp
index f2f3678eb14..1c5497a95e4 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/empty.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
     M m;
@@ -41,7 +40,6 @@ int main(int, char**)
     m.clear();
     assert(m.empty());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/eq.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/eq.pass.cpp
index 9d391cec825..ad278071785 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/eq.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/eq.pass.cpp
@@ -90,7 +90,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -155,7 +154,6 @@ int main(int, char**)
         assert( (c1 == c2));
         assert(!(c1 != c2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
index b5dc3da9750..af46254fc8f 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
         assert(std::distance(r.first, r.second) == 1);
         assert(*r.first == 50);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef C::const_iterator I;
@@ -77,7 +76,6 @@ int main(int, char**)
         assert(std::distance(r.first, r.second) == 1);
         assert(*r.first == 50);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
index 398b52b6f58..f15157c028b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
         assert(std::distance(r.first, r.second) == 1);
         assert(*r.first == 50);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef C::iterator I;
@@ -77,7 +76,6 @@ int main(int, char**)
         assert(std::distance(r.first, r.second) == 1);
         assert(*r.first == 50);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
index 48f4eb47ef3..3494467feca 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
@@ -55,7 +55,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -80,7 +79,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#endif
 #if TEST_STD_VER >= 2014
     {
     //  This is LWG #2059
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_key.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_key.pass.cpp
index aaf9db1b288..237da07c614 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_key.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_key.pass.cpp
@@ -21,7 +21,6 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
@@ -35,7 +34,6 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 
     return p == part.end();
 }
-#endif
 
 int main(int, char**)
 {
@@ -95,7 +93,6 @@ int main(int, char**)
         assert(c.erase(3) == 0);
         assert(c.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -171,7 +168,6 @@ int main(int, char**)
 
     assert (only_deletions (m, m2));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_range.pass.cpp
index 585796031d6..75cdfcab9e2 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/erase_range.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -90,7 +89,6 @@ int main(int, char**)
         assert(c.size() == 0);
         assert(k == c.end());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_const.pass.cpp
index e4eb55b1e6a..234979ff849 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_const.pass.cpp
@@ -42,7 +42,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -63,7 +62,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_non_const.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_non_const.pass.cpp
index 7b9e2231362..c5fc5ef37cc 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_non_const.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/find_non_const.pass.cpp
@@ -42,7 +42,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
@@ -63,7 +62,6 @@ int main(int, char**)
         i = c.find(5);
         assert(i == c.cend());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
index f4eccf8c42b..2fa222aa432 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
@@ -54,13 +54,11 @@ void do_insert_const_lvalue_test()
 int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_set<double> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
         do_insert_const_lvalue_test<C>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
index 5c7589bdc37..dba7939d143 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
@@ -55,13 +55,11 @@ void do_insert_hint_const_lvalue_test()
 int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_set<double> >();
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
         do_insert_hint_const_lvalue_test<C>();
     }
-#endif
 #if _LIBCUDACXX_DEBUG >= 1
     {
         typedef std::unordered_set<double> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
index 4866b337e23..d56b7723dc3 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<MoveOnly> C;
         typedef C::iterator R;
@@ -110,7 +109,6 @@ int main(int, char**)
         assert(c.size() == 3);
         assert(*r == 5);
     }
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
index 3dc8aa1b219..d0a8efcbd60 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -66,7 +65,6 @@ int main(int, char**)
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
index f282a725fd1..451d4b05d44 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(*r.first == 5.5);
         assert(r.second);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<MoveOnly> C;
         typedef std::pair<C::iterator, bool> R;
@@ -126,7 +125,6 @@ int main(int, char**)
         assert(*r.first == 5);
         assert(r.second);
     }
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp
index 4403d9b2855..15970ef780d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp
@@ -66,7 +66,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -107,7 +106,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
-#endif
 #if TEST_STD_VER > 2011
     { // N3644 testing
         typedef std::unordered_set<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/load_factor.pass.cpp
index 8ba74d06178..c20a969bec6 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/load_factor.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -71,7 +70,6 @@ int main(int, char**)
         const C c;
         assert(c.load_factor() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/local_iterators.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/local_iterators.pass.cpp
index 47bf6129239..e6cda3b8b1b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/local_iterators.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/local_iterators.pass.cpp
@@ -203,7 +203,6 @@ int main(int, char**)
         assert(std::distance(i, j) == 1);
         assert(*i == 4);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -384,7 +383,6 @@ int main(int, char**)
         assert(std::distance(i, j) == 1);
         assert(*i == 4);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
index 673ad7c2876..91abfe24408 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
@@ -27,14 +27,12 @@ int main(int, char**)
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         const C c;
         assert(c.max_bucket_count() > 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_load_factor.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
index 17ba9c0f0ec..e73b63e8cc4 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
@@ -39,7 +39,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -54,7 +53,6 @@ int main(int, char**)
         c.max_load_factor(2.5);
         assert(c.max_load_factor() == 2.5);
     }
-#endif
 #if _LIBCUDACXX_DEBUG_LEVEL >= 1
     {
         typedef std::unordered_set<int> C;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/rehash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/rehash.pass.cpp
index abbd2d78e87..cb51ab28928 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/rehash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/rehash.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -98,7 +97,6 @@ int main(int, char**)
         LIBCPP_ASSERT(c.bucket_count() == 31);
         test(c);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/reserve.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/reserve.pass.cpp
index 535ab83af39..2928eb09381 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/reserve.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/reserve.pass.cpp
@@ -73,7 +73,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
@@ -101,7 +100,6 @@ int main(int, char**)
         assert(c.bucket_count() >= 16);
         test(c);
     }
-#endif
     reserve_invariant(20);
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/size.pass.cpp
index e5b347de4f8..ea1d1c484a8 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/size.pass.cpp
@@ -38,7 +38,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
     M m;
@@ -57,7 +56,6 @@ int main(int, char**)
     m.erase(m.begin());
     assert(m.size() == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
index 447f312c4e2..40467061fd2 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -386,7 +386,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -566,7 +565,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/types.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/types.pass.cpp
index a04be7e68ee..2eea8a6e0e2 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/types.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::size_t>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<short, std::hash<short>,
                                   std::equal_to<short>, min_allocator<short>> C;
@@ -65,7 +64,6 @@ int main(int, char**)
         static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), "");
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
index d0d77212103..20aede5627c 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -105,7 +104,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
index e40c490a3e9..adf25fe5221 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
@@ -138,7 +138,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
@@ -184,7 +183,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
index ad2ff40ace5..588af0d5326 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
@@ -66,7 +66,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int,
                                    test_hash<int>,
@@ -143,7 +142,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
index 6d53fb98a2a..470b9d21cfb 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int,
                                    test_hash<int>,
@@ -106,7 +105,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
index abd52636913..72047c77b2b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -104,7 +103,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter.pass.cpp
index e7fd57e1e6d..78a7587140d 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter.pass.cpp
@@ -63,7 +63,6 @@ int main(int, char**)
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int,
                                    test_hash<int>,
@@ -166,7 +165,6 @@ int main(int, char**)
         assert(c.max_load_factor() == 1);
     }
 
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size.pass.cpp
index 30ba295e4a8..588d56253ce 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size.pass.cpp
@@ -64,7 +64,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int,
                                    test_hash<int>,
@@ -99,7 +98,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash.pass.cpp
index cb226c34ac7..b217a064bf8 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash.pass.cpp
@@ -66,7 +66,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int,
                                    test_hash<int>,
@@ -102,7 +101,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal.pass.cpp
index f1fc7e61dc9..2b08474f863 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int,
                                    test_hash<int>,
@@ -104,7 +103,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
index 78aba26b05f..8751cc0c532 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/iter_iter_size_hash_equal_allocator.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<int,
                                    test_hash<int>,
@@ -107,7 +106,6 @@ int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
index 9387f69ad08..85831d67312 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -62,7 +61,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
index 8942e2accde..efa10fcd371 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -66,7 +65,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
index e076aa029af..a2e1837acb2 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -68,7 +67,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
index ec053883277..a10afc9704b 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::unordered_set<NotConstructible,
                                    test_hash<NotConstructible>,
@@ -69,7 +68,6 @@ int main(int, char**)
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
index 83ba3bc9f47..7813e622a47 100644
--- a/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ b/libcudacxx/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -394,7 +394,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef test_hash<int> Hash;
         typedef test_equal_to<int> Compare;
@@ -574,7 +573,6 @@ int main(int, char**)
         assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/depr/depr.c.headers/stdarg_h.pass.cpp b/libcudacxx/libcxx/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
index 175194b0585..ce1b466f357 100644
--- a/libcudacxx/libcxx/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
+++ b/libcudacxx/libcxx/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
@@ -16,11 +16,9 @@
 #error va_arg not defined
 #endif
 
-#if TEST_STD_VER >= 2011
 #  ifndef va_copy
 #    error va_copy is not defined when c++ >= 11
 #  endif
-#endif
 
 #ifndef va_end
 #error va_end not defined
diff --git a/libcudacxx/libcxx/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp b/libcudacxx/libcxx/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
index 0cb00fe897c..167bc0dc0e1 100644
--- a/libcudacxx/libcxx/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
+++ b/libcudacxx/libcxx/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
@@ -13,17 +13,12 @@
 #include <experimental/filesystem>
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
 #ifndef __cpp_lib_experimental_filesystem
 #error Filesystem feature test macro is not defined  (__cpp_lib_experimental_filesystem)
 #elif __cpp_lib_experimental_filesystem != 201406L
 #error Filesystem feature test macro has an incorrect value (__cpp_lib_experimental_filesystem)
 #endif
-#else // TEST_STD_VER < 2011
-#ifdef __cpp_lib_experimental_filesystem
-#error Filesystem feature test macro should not be defined in c++03
-#endif
-#endif
+
 
 int main(int, char**) {
   return 0;
diff --git a/libcudacxx/libcxx/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp b/libcudacxx/libcxx/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
index 2354f5f6f36..a4ea2c4c7b7 100644
--- a/libcudacxx/libcxx/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
+++ b/libcudacxx/libcxx/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
@@ -17,11 +17,7 @@
 
 using namespace std::filesystem;
 
-#if TEST_STD_VER >= 2011
 // expected-error@-3 {{no namespace named 'filesystem' in namespace 'std';}}
-#else
-// expected-error@-5 {{expected namespace name}}
-#endif
 
 int main(int, char**) {
 
diff --git a/libcudacxx/libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp b/libcudacxx/libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
index bd3a3a1ba13..59896c82f29 100644
--- a/libcudacxx/libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
+++ b/libcudacxx/libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
@@ -27,9 +27,7 @@ int main(int, char**)
     static_assert((!std::is_convertible<std::ios, void*>::value), "");
     static_assert((!std::is_convertible<std::ios, int>::value), "");
     static_assert((!std::is_convertible<std::ios const&, int>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((!std::is_convertible<std::ios, bool>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/iterators/iterator.range/begin-end.fail.cpp b/libcudacxx/libcxx/test/std/iterators/iterator.range/begin-end.fail.cpp
index fa20b413abd..758acd9b9a5 100644
--- a/libcudacxx/libcxx/test/std/iterators/iterator.range/begin-end.fail.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/iterator.range/begin-end.fail.cpp
@@ -8,10 +8,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER < 2011
-#error
-#else
-
 // <iterator>
 // template <class C> auto begin(C& c) -> decltype(c.begin());
 // template <class C> auto begin(const C& c) -> decltype(c.begin());
@@ -49,4 +45,3 @@ int main(int, char**) {
 
   return 0;
 }
-#endif
diff --git a/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp b/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
index 3dfe6569c50..f831cdee82a 100644
--- a/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
@@ -42,7 +42,6 @@ int main(int, char**)
         test(random_access_iterator<char*>(s+5), 4, '0');
         test(s+5, 4, '0');
     }
-#if TEST_STD_VER >= 2011
     {
         int i[5];
         typedef std::unique_ptr<int, do_nothing> Ptr;
@@ -51,7 +50,6 @@ int main(int, char**)
             p[j].reset(i+j);
         test(p, 3, Ptr(i+3));
     }
-#endif
 #if TEST_STD_VER > 2014
     {
     constexpr const char *p = "123456789";
diff --git a/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp b/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
index 50d6dd9364b..06927fe184b 100644
--- a/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
@@ -53,13 +53,11 @@ int main(int, char**) {
     A a;
     test(&a, A());
   }
-#if TEST_STD_VER >= 2011
   {
     int i;
     std::unique_ptr<int, do_nothing> p(&i);
     test(&p, std::unique_ptr<int, do_nothing>(&i));
   }
-#endif
 #if TEST_STD_VER > 2014
   {
     constexpr const char *p = "123456789";
diff --git a/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp b/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
index c80948e4705..02a1f95517a 100644
--- a/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -117,7 +117,6 @@ int main(int, char**) {
   test<random_access_iterator<char*> >();
   test<char*>();
 
-#if TEST_STD_VER >= 2011
   {
       typedef DummyIt<int, int> T;
       typedef std::move_iterator<T> It;
@@ -145,7 +144,6 @@ int main(int, char**) {
       typedef std::move_iterator<T> It;
       static_assert(std::is_same<It::reference, int&&>::value, "");
   }
-#endif
 
 #if TEST_STD_VER > 2014
   test<contiguous_iterator<char*>>();
diff --git a/libcudacxx/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/minus.pass.cpp b/libcudacxx/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/minus.pass.cpp
index 02b29aca54a..baa404321d1 100644
--- a/libcudacxx/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/minus.pass.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/minus.pass.cpp
@@ -50,10 +50,8 @@ TEST_CONSTEXPR_CXX17 bool tests() {
     // Test non-subtractable base iterator types
     static_assert( HasMinus<std::reverse_iterator<int*>, std::reverse_iterator<int*> >::value, "");
     static_assert( HasMinus<std::reverse_iterator<int*>, std::reverse_iterator<const int*> >::value, "");
-#if TEST_STD_VER >= 2011
     static_assert(!HasMinus<std::reverse_iterator<int*>, std::reverse_iterator<char*> >::value, "");
     static_assert(!HasMinus<std::reverse_iterator<bidirectional_iterator<int*> >, std::reverse_iterator<bidirectional_iterator<int*> > >::value, "");
-#endif
 
     return true;
 }
diff --git a/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp b/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
index 70a2e546252..bb22829cc2b 100644
--- a/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
@@ -21,13 +21,9 @@ struct S { S(); }; // not constexpr
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     {
     constexpr std::istream_iterator<S> it;
     }
-#else
-#error "C++11 only test"
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
index ecd5cf5fcd5..87cfff3e8ff 100644
--- a/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
@@ -48,10 +48,8 @@ int main(int, char**)
     typedef std::istream_iterator<int> T;
     T it;
     assert(it == T());
-#if TEST_STD_VER >= 2011
     constexpr T it2;
     (void)it2;
-#endif
     }
 
 #if TEST_STD_VER > 2014
diff --git a/libcudacxx/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
index 8159c7feda9..d75a7060331 100644
--- a/libcudacxx/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
@@ -27,19 +27,15 @@ int main(int, char**)
         typedef std::istreambuf_iterator<char> T;
         T it;
         assert(it == T());
-#if TEST_STD_VER >= 2011
         constexpr T it2;
         (void)it2;
-#endif
     }
     {
         typedef std::istreambuf_iterator<wchar_t> T;
         T it;
         assert(it == T());
-#if TEST_STD_VER >= 2011
         constexpr T it2;
         (void)it2;
-#endif
     }
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/language.support/support.runtime/cstdarg.pass.cpp b/libcudacxx/libcxx/test/std/language.support/support.runtime/cstdarg.pass.cpp
index de069e25776..9dfdc48161f 100644
--- a/libcudacxx/libcxx/test/std/language.support/support.runtime/cstdarg.pass.cpp
+++ b/libcudacxx/libcxx/test/std/language.support/support.runtime/cstdarg.pass.cpp
@@ -16,10 +16,8 @@
 #error va_arg not defined
 #endif
 
-#if TEST_STD_VER >= 2011
-#  ifndef va_copy
-#    error va_copy is not defined when c++ >= 11
-#  endif
+#ifndef va_copy
+#  error va_copy not defined
 #endif
 
 #ifndef va_end
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.members/construct.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.members/construct.pass.cpp
index daed41df7f9..f815280eddf 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.members/construct.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.members/construct.pass.cpp
@@ -40,7 +40,6 @@ test()
     assert(c.real() == 10.5);
     assert(c.imag() == -9.5);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<T> c;
     static_assert(c.real() == 0, "");
@@ -61,7 +60,6 @@ test()
     static_assert(c.real() == 10.5, "");
     static_assert(c.imag() == -9.5, "");
     }
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
index ce80865e70e..5433532390d 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<float> cd(2.5, 3.5);
     constexpr std::complex<double> cf(cd);
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
index 5ea3b817573..2521e857be5 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<float> cd(2.5, 3.5);
     constexpr std::complex<double> cf = cd;
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
index bf9b3a78385..bbae0bbb013 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<long double> cd(2.5, 3.5);
     constexpr std::complex<double> cf(cd);
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
index b4470958fd0..0f1829a26f8 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<double> cd(2.5, 3.5);
     constexpr std::complex<float> cf(cd);
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
index 7fe65902351..8ec1695495d 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<long double> cd(2.5, 3.5);
     constexpr std::complex<float> cf(cd);
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
index d5fbe842908..b440a36132c 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<double> cd(2.5, 3.5);
     constexpr std::complex<long double> cf(cd);
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
index 70746a2515c..fccbde1f11a 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<double> cd(2.5, 3.5);
     constexpr std::complex<long double> cf = cd;
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
index a5b22751b0d..c43812f2028 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<float> cd(2.5, 3.5);
     constexpr std::complex<long double> cf(cd);
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
index e5e0a740edd..3ba4603ed2b 100644
--- a/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
@@ -28,14 +28,12 @@ int main(int, char**)
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::complex<float> cd(2.5, 3.5);
     constexpr std::complex<long double> cf = cd;
     static_assert(cf.real() == cd.real(), "");
     static_assert(cf.imag() == cd.imag(), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp b/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
index 030589e62f4..d8700505a8e 100644
--- a/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
@@ -38,7 +38,6 @@ test()
         assert(ib[i] == ir[i]);
 }
 
-#if TEST_STD_VER >= 2011
 
 class Y;
 
@@ -73,7 +72,6 @@ class Y
     void operator=(const X& x) {i_ = x.i_;}
 };
 
-#endif
 
 int main(int, char**)
 {
@@ -107,11 +105,9 @@ int main(int, char**)
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
 
-#if TEST_STD_VER >= 2011
     X x[3] = {X(1), X(2), X(3)};
     Y y[3] = {Y(1), Y(2), Y(3)};
     std::adjacent_difference(x, x+3, y);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp b/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
index e7d791060c2..b367cc671e1 100644
--- a/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
@@ -40,7 +40,6 @@ test()
         assert(ib[i] == ir[i]);
 }
 
-#if TEST_STD_VER >= 2011
 
 class Y;
 
@@ -75,7 +74,6 @@ class Y
     void operator=(const X& x) {i_ = x.i_;}
 };
 
-#endif
 
 
 int main(int, char**)
@@ -110,11 +108,9 @@ int main(int, char**)
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
 
-#if TEST_STD_VER >= 2011
     X x[3] = {X(1), X(2), X(3)};
     Y y[3] = {Y(1), Y(2), Y(3)};
     std::adjacent_difference(x, x+3, y, std::minus<X>());
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
index 6dd63d0057a..f32ff9ede9e 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
@@ -36,13 +36,9 @@ test1()
     typedef std::ranlux24 E;
     static_assert((E::block_size == 223), "");
     static_assert((E::used_block == 23), "");
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFF), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFF));
-#endif
+
     where(E::block_size);
     where(E::used_block);
 }
@@ -53,13 +49,9 @@ test2()
     typedef std::ranlux48 E;
     static_assert((E::block_size == 389), "");
     static_assert((E::used_block == 11), "");
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFFFFFFFFull), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFFFFFFFFull));
-#endif
+
     where(E::block_size);
     where(E::used_block);
 }
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
index cb3e27fd37f..8bbb68008c8 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
@@ -31,11 +31,6 @@ class rand1
     static_assert(Min < Max, "rand1 invalid parameters");
 public:
 
-#if TEST_STD_VER < 2011 && defined(_LIBCUDACXX_VERSION)
-    // Workaround for lack of constexpr in C++03
-    static const result_type _Min = Min;
-    static const result_type _Max = Max;
-#endif
 
     static TEST_CONSTEXPR result_type min() {return Min;}
     static TEST_CONSTEXPR result_type max() {return Max;}
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
index 8a5f7828093..1f9fb03a14d 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
@@ -33,11 +33,6 @@ class rand1
     static_assert(Min < Max, "rand1 invalid parameters");
 public:
 
-#if TEST_STD_VER < 2011 && defined(_LIBCUDACXX_VERSION)
-    // Workaround for lack of constexpr in C++03
-    static const result_type _Min = Min;
-    static const result_type _Max = Max;
-#endif
 
     static TEST_CONSTEXPR result_type min() {return Min;}
     static TEST_CONSTEXPR result_type max() {return Max;}
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
index f281c5f8918..24e9a23f733 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
@@ -29,26 +29,16 @@ void
 test1()
 {
     typedef std::independent_bits_engine<std::ranlux24, 32, unsigned> E;
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFFFF), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFFFF));
-#endif
 }
 
 void
 test2()
 {
     typedef std::independent_bits_engine<std::ranlux48, 64, unsigned long long> E;
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFFFFFFFFFFFFull), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFFFFFFFFFFFFull));
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
index 6a0e237de7c..076c13e042f 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
@@ -31,12 +31,6 @@ class rand1
     static_assert(Min < Max, "rand1 invalid parameters");
 public:
 
-#if TEST_STD_VER < 2011 && defined(_LIBCUDACXX_VERSION)
-    // Workaround for lack of constexpr in C++03
-    static const result_type _Min = Min;
-    static const result_type _Max = Max;
-#endif
-
     static TEST_CONSTEXPR result_type min() {return Min;}
     static TEST_CONSTEXPR result_type max() {return Max;}
 
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
index 0be350cb35a..75e73659fa4 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
@@ -33,12 +33,6 @@ class rand1
     static_assert(Min < Max, "rand1 invalid parameters");
 public:
 
-#if TEST_STD_VER < 2011 && defined(_LIBCUDACXX_VERSION)
-    // Workaround for lack of constexpr in C++03
-    static const result_type _Min = Min;
-    static const result_type _Max = Max;
-#endif
-
     static TEST_CONSTEXPR  result_type min() {return Min;}
     static TEST_CONSTEXPR  result_type max() {return Max;}
 
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
index ac906235a29..2eeac5967a2 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
@@ -34,13 +34,8 @@ test1()
 {
     typedef std::knuth_b E;
     static_assert(E::table_size == 256, "");
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 1), "");
     static_assert((E::max() == 2147483646), "");
-#else
-    assert((E::min() == 1));
-    assert((E::max() == 2147483646));
-#endif
     where(E::table_size);
 }
 
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
index c0a3880eafb..85cd3a2063b 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
@@ -38,22 +38,14 @@ test1()
     static_assert((LCE::multiplier == a), "");
     static_assert((LCE::increment == c), "");
     static_assert((LCE::modulus == m), "");
-#if TEST_STD_VER >= 2011
     static_assert((LCE::min() == (c == 0u ? 1u: 0u)), "");
-#else
-    assert((LCE::min() == (c == 0u ? 1u: 0u)));
-#endif
 
 #ifdef TEST_COMPILER_MSVC
     #pragma warning(push)
     #pragma warning(disable: 4310) // cast truncates constant value
 #endif // TEST_COMPILER_MSVC
 
-#if TEST_STD_VER >= 2011
     static_assert((LCE::max() == result_type(m - 1u)), "");
-#else
-    assert((LCE::max() == result_type(m - 1u)));
-#endif
 
 #ifdef TEST_COMPILER_MSVC
     #pragma warning(pop)
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
index 2d787a09e4d..8df8514672f 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
@@ -25,11 +25,9 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
-#if TEST_STD_VER >= 2011
 #include <initializer_list>
 
 #include "test_macros.h"
-#endif
 
 struct all_zero_seed_seq {
   typedef unsigned int result_type;
@@ -38,9 +36,7 @@ struct all_zero_seed_seq {
 
   template <typename InputIterator>
   all_zero_seed_seq(InputIterator, InputIterator) {}
-#if TEST_STD_VER >= 2011
   all_zero_seed_seq(std::initializer_list<result_type>) {}
-#endif
 
   template <typename RandomAccessIterator>
   void generate(RandomAccessIterator rb, RandomAccessIterator re) {
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
index 97549f08804..c80094228a1 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
@@ -61,13 +61,8 @@ test1()
     static_assert((E::tempering_c == 0xefc60000), "");
     static_assert((E::tempering_l == 18), "");
     static_assert((E::initialization_multiplier == 1812433253), "");
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFFFF), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFFFF));
-#endif
     static_assert((E::default_seed == 5489u), "");
     where(E::word_size);
     where(E::state_size);
@@ -102,13 +97,8 @@ test2()
     static_assert((E::tempering_c == 0xfff7eee000000000ull), "");
     static_assert((E::tempering_l == 43), "");
     static_assert((E::initialization_multiplier == 6364136223846793005ull), "");
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFFFFFFFFFFFFull), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFFFFFFFFFFFFull));
-#endif
     static_assert((E::default_seed == 5489u), "");
     where(E::word_size);
     where(E::state_size);
diff --git a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
index 5091c58a592..6723abaa3f9 100644
--- a/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
+++ b/libcudacxx/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
@@ -39,13 +39,8 @@ test1()
     static_assert((E::word_size == 24), "");
     static_assert((E::short_lag == 10), "");
     static_assert((E::long_lag == 24), "");
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFF), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFF));
-#endif
     static_assert((E::default_seed == 19780503u), "");
     where(E::word_size);
     where(E::short_lag);
@@ -60,13 +55,8 @@ test2()
     static_assert((E::word_size == 48), "");
     static_assert((E::short_lag == 5), "");
     static_assert((E::long_lag == 12), "");
-#if TEST_STD_VER >= 2011
     static_assert((E::min() == 0), "");
     static_assert((E::max() == 0xFFFFFFFFFFFFull), "");
-#else
-    assert((E::min() == 0));
-    assert((E::max() == 0xFFFFFFFFFFFFull));
-#endif
     static_assert((E::default_seed == 19780503u), "");
     where(E::word_size);
     where(E::short_lag);
diff --git a/libcudacxx/libcxx/test/std/re/re.alg/re.alg.search/grep.pass.cpp b/libcudacxx/libcxx/test/std/re/re.alg/re.alg.search/grep.pass.cpp
index 2d864afb5ef..a901d654265 100644
--- a/libcudacxx/libcxx/test/std/re/re.alg/re.alg.search/grep.pass.cpp
+++ b/libcudacxx/libcxx/test/std/re/re.alg/re.alg.search/grep.pass.cpp
@@ -45,9 +45,7 @@ extern "C" void LLVMFuzzerTestOneInput(const char *data)
 void fuzz_tests()  // patterns that the fuzzer has found
 {
 // Raw string literals are a C++11 feature.
-#if TEST_STD_VER >= 2011
     LLVMFuzzerTestOneInput(R"XX(Õ)_%()()((\8'_%()_%()_%()_%(()_%()_%()_%(.t;)()¥f()_%()(.)_%;)()!¥f(((()()XX");
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
index 3bfc49af741..52428c9291b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
     test(S("123"), 2);
     test(S("123"), 3);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0);
@@ -78,7 +77,6 @@ int main(int, char**)
     test(S("123"), 2);
     test(S("123"), 3);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
index 54334fa84e7..230a402d7aa 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
@@ -43,13 +43,11 @@ int main(int, char**)
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
     }
-#endif
 #ifdef _LIBCUDACXX_DEBUG
     {
         std::string s;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_back.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_back.pass.cpp
index a722a8de746..cd0ced557e8 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_back.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     assert(s.back() == 0);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s(1, '\0');
@@ -42,7 +41,6 @@ int main(int, char**)
     assert(s.back() == 0);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cback.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cback.pass.cpp
index dbf73391078..632e346e0a0 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cback.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cback.pass.cpp
@@ -31,14 +31,12 @@ int main(int, char**)
     assert(s.back() == 0);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
     assert(s.back() == 0);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cfront.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
index 91640418322..bc98ebf789e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
@@ -31,14 +31,12 @@ int main(int, char**)
     assert(s.front() == 0);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
     assert(s.front() == 0);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cindex.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
index 96ad4927244..7f44ca94add 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
     assert(s[1] == 0);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
@@ -40,7 +39,6 @@ int main(int, char**)
     assert(s[1] == 0);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_front.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_front.pass.cpp
index 24a9ed65e97..7c7806a8ac5 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_front.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     assert(s.front() == 0);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s(1, '\0');
@@ -42,7 +41,6 @@ int main(int, char**)
     assert(s.front() == 0);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_index.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_index.pass.cpp
index 77228009107..d94e8b7644f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_index.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/db_index.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
     assert(s[1] == 0);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
@@ -40,7 +39,6 @@ int main(int, char**)
     assert(s[1] == 0);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
index c2873f6c1f5..9a238a756eb 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
@@ -43,13 +43,11 @@ int main(int, char**)
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
     }
-#endif
 #ifdef _LIBCUDACXX_DEBUG
     {
         std::string s;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
index c4c5510ca33..3dc2803611a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
     const S s2 = S();
     assert(s2[0] == '\0');
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s("0123456789");
@@ -58,7 +57,6 @@ int main(int, char**)
     const S s2 = S();
     assert(s2[0] == '\0');
     }
-#endif
 #ifdef _LIBCUDACXX_DEBUG
     {
         std::string s;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
index b0a1605e87f..62ba396a8bc 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
@@ -53,13 +53,11 @@ int main(int, char**)
     s.erase(50);
     test(s);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     assert(s.capacity() > 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
index 643b3adc66c..3c8fd9ca65a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
@@ -39,7 +39,6 @@ int main(int, char**)
     s.erase(50);
     test(s);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
@@ -53,7 +52,6 @@ int main(int, char**)
     s.erase(50);
     test(s);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
index 6c873a564b6..5eb282e7f97 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -32,14 +32,12 @@ int main(int, char**)
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
index 52a57c7b496..a46b38f78e3 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
@@ -31,14 +31,12 @@ int main(int, char**)
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
index 0453ef407c4..79c6594630d 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
@@ -63,14 +63,12 @@ int main(int, char**)
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
index 7aa5f64728c..59368bfd5d2 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
@@ -44,14 +44,12 @@ int main(int, char**)
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
index 94b59ae2d8c..df7bce20b78 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
@@ -103,7 +103,6 @@ int main(int, char**)
     test(s, S::npos);
     }
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     {
@@ -135,7 +134,6 @@ int main(int, char**)
     test(s, S::npos);
     }
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
index e69c36da218..6b20efdb31f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
     test(S(), S::npos, S("not going to happen"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, S());
@@ -89,7 +88,6 @@ int main(int, char**)
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
     test(S(), S::npos, S("not going to happen"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
index 193f7c1fd76..1818c29323b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
     test(S(), S::npos, 'a', S("not going to happen"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, 'a', S());
@@ -89,7 +88,6 @@ int main(int, char**)
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
     test(S(), S::npos, 'a', S("not going to happen"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
index ea9d18c3cff..676f31b7ff2 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
@@ -44,7 +44,6 @@ int main(int, char**)
     s.erase(50);
     test(s);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
@@ -58,7 +57,6 @@ int main(int, char**)
     s.erase(50);
     test(s);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
index 96f31dccae9..0ad5caf726a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
@@ -31,14 +31,12 @@ int main(int, char**)
     test(S("123"), 3);
     test(S("12345678901234567890123456789012345678901234567890"), 50);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0);
     test(S("123"), 3);
     test(S("12345678901234567890123456789012345678901234567890"), 50);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
index 60e097c4534..586119c1ffd 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
@@ -124,7 +124,6 @@ int main(int, char**)
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A(8));
     }
 
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
@@ -154,7 +153,6 @@ int main(int, char**)
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10, A());
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A());
     }
-#endif
     {
     typedef std::string S;
     typedef std::string_view SV;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp
index 7c8a2a77e07..a66d10cdc45 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -24,7 +24,7 @@ test()
     {
 #if TEST_STD_VER > 2014
     static_assert((noexcept(S{})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
     S s;
@@ -37,7 +37,7 @@ test()
     {
 #if TEST_STD_VER > 2014
     static_assert((noexcept(S{typename S::allocator_type{}})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type(5));
@@ -49,7 +49,6 @@ test()
     }
 }
 
-#if TEST_STD_VER >= 2011
 
 template <class S>
 void
@@ -58,9 +57,8 @@ test2()
     {
 #if TEST_STD_VER > 2014
     static_assert((noexcept(S{})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
-#endif
     S s;
     LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
@@ -69,9 +67,11 @@ test2()
     assert(s.get_allocator() == typename S::allocator_type());
     }
     {
+#endif
+
 #if TEST_STD_VER > 2014
     static_assert((noexcept(S{typename S::allocator_type{}})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type{});
@@ -88,10 +88,8 @@ test2()
 int main(int, char**)
 {
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
-#if TEST_STD_VER >= 2011
     test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
     test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
index 8697050d50d..5dccaf1859c 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     test(S("123456789"), 'a');
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a');
@@ -45,7 +44,6 @@ int main(int, char**)
     test(S("123456789"), 'a');
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
index ca8f9f31144..8731ee09412 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**)
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -45,7 +44,6 @@ int main(int, char**)
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
index fd2429f9009..b578087312b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -97,7 +97,6 @@ int main(int, char**)
     test(S("1"), A(5));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -126,7 +125,6 @@ int main(int, char**)
     assert(s1 == p1);
     assert(s2 == p2);
     }
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
index 6aafc9797dd..a9c1c494fd4 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**)
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
@@ -66,7 +65,6 @@ int main(int, char**)
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
index 8f183805920..456a71de0e5 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -91,7 +91,6 @@ bool test() {
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A(2));
   }
-#if TEST_STD_VER >= 2011
   {
     typedef min_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
@@ -120,7 +119,6 @@ bool test() {
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A());
   }
-#endif
   {
       static_assert((!std::is_constructible<std::string, std::string,
                                             std::string>::value),
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
index 2f19f7050c0..d3103cc7654 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -41,7 +41,7 @@ int main(int, char**)
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 2014
     static_assert((noexcept(S{})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     test(S(), A(3));
@@ -55,7 +55,7 @@ int main(int, char**)
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 2014
     static_assert((noexcept(S{})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe" );
@@ -67,7 +67,7 @@ int main(int, char**)
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 2014
     static_assert((noexcept(S{})), "" );
-#elif TEST_STD_VER >= 2011
+#else
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     test(S(), A());
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
index 90a3d620cc0..a220b35a460 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -68,7 +68,6 @@ int main(int, char**)
     test("123456798012345679801234567980123456798012345679801234567980");
     test("123456798012345679801234567980123456798012345679801234567980", A(2));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
 
@@ -84,7 +83,6 @@ int main(int, char**)
     test("123456798012345679801234567980123456798012345679801234567980");
     test("123456798012345679801234567980123456798012345679801234567980", A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
index 89b0bc9ee56..da957f19f69 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "");
@@ -68,7 +67,6 @@ int main(int, char**)
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
index 0c8ff386ffb..7c94b0efa38 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A(2));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
 
@@ -81,7 +80,6 @@ int main(int, char**)
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A());
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
index f889889a852..57fc49060ef 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -100,7 +100,6 @@ int main(int, char**)
     test(static_cast<char>(100), static_cast<char>(65));
     test(static_cast<char>(100), static_cast<char>(65), A(3));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
 
@@ -119,7 +118,6 @@ int main(int, char**)
     test(static_cast<char>(100), static_cast<char>(65));
     test(static_cast<char>(100), static_cast<char>(65), A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
index c1d260c75c5..eea335e7231 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
@@ -89,7 +89,6 @@ int main(int, char**)
     test(SV("123456798012345679801234567980123456798012345679801234567980"));
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A(2));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
@@ -106,7 +105,6 @@ int main(int, char**)
     test(SV("123456798012345679801234567980123456798012345679801234567980"));
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
index af6281d58d9..da6327babde 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**)
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
@@ -69,7 +68,6 @@ int main(int, char**)
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
index b3da9df828a..1d8fc3cc94e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -129,7 +129,6 @@ test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
 #endif
 }
 
-#if TEST_STD_VER >= 2011
 #ifndef TEST_HAS_NO_EXCEPTIONS
 void test2583()
 {   // LWG #2583
@@ -143,7 +142,6 @@ void test2583()
     assert(false);
 }
 #endif
-#endif
 
 int main(int, char**)
 {
@@ -185,7 +183,6 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -227,7 +224,6 @@ int main(int, char**)
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
     test2583();
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
index e7e4c99b0c7..9841c99444b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
@@ -38,13 +38,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
index 76cf3db6414..6535b7977f8 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
@@ -35,13 +35,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
index 206cc89e297..140dc00e913 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
@@ -31,13 +31,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
index 772985bea78..d139553b21d 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
@@ -35,13 +35,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
index 2bb46a5ca35..bba18f5379b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
@@ -31,13 +31,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
index 3308863c9b6..24df7b85d62 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     (void) b;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s1;
@@ -42,7 +41,6 @@ int main(int, char**)
     (void) b;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
index 141ad9c48ce..67df8640ef6 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     (void) i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s1;
@@ -42,7 +41,6 @@ int main(int, char**)
     (void) i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
index 9c012a04fb6..030a46f3120 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
@@ -33,7 +33,6 @@ int main(int, char**)
     assert(i[1] == 0);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
@@ -42,7 +41,6 @@ int main(int, char**)
     assert(i[1] == 0);
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
index 1e6874de904..97d21819386 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
@@ -35,7 +35,6 @@ int main(int, char**)
     i += 2;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
@@ -46,7 +45,6 @@ int main(int, char**)
     i += 2;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
index fd65ef346bf..08e3f944786 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
     --i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
@@ -44,7 +43,6 @@ int main(int, char**)
     --i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
index 30bbcc1d233..f22db8a542a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
@@ -44,7 +43,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
index 5cee645c98f..d2a058e18c8 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
@@ -32,7 +32,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
@@ -40,7 +39,6 @@ int main(int, char**)
     (void) *i;
     assert(false);
     }
-#endif
 }
 
 #else
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
index 06dc1b22a8e..d61a9002c1e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
@@ -41,13 +41,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
index 72168d16e23..5d289a8f192 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
@@ -38,13 +38,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
index 767e5e52258..ba63157efbc 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
@@ -41,13 +41,11 @@ int main(int, char**)
     test(S());
     test(S("123"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
index c37f49939ef..82115c01c78 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
@@ -103,7 +103,6 @@ int main(int, char**)
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
@@ -129,7 +128,6 @@ int main(int, char**)
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
     }
-#endif
     {
     typedef std::string S;
     typedef std::string_view SV;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
index e4a9554023c..135ef23e997 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -113,9 +113,7 @@ void test_string() {
 
 bool test() {
   test_string<std::string>();
-#if TEST_STD_VER >= 2011
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
-#endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
index a37d09273e1..20c1a377085 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", S());
@@ -59,7 +58,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
     }
-#endif
 
     { // test appending to self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
index b67168e61fc..abee4867fb2 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", 0, S());
@@ -68,7 +67,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("1234567890123456789012345678901234567890"));
     }
-#endif
 
     { // test appending to self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
index ebeaaedba4c..4bd140da77e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -39,14 +39,12 @@ int main(int, char**)
     test(S("12345"), 'a', S("12345a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a', S(1, 'a'));
     test(S("12345"), 'a', S("12345a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
-#endif
 
     {
 // https://bugs.llvm.org/show_bug.cgi?id=31454
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
index 5b2c41c1635..a30884f03ea 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
     test(S("12345678901234567890"), 1, 'a', S("12345678901234567890a"));
     test(S("12345678901234567890"), 10, 'a', S("12345678901234567890aaaaaaaaaa"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, 'a', S());
@@ -59,7 +58,6 @@ int main(int, char**)
     test(S("12345678901234567890"), 1, 'a', S("12345678901234567890a"));
     test(S("12345678901234567890"), 10, 'a', S("12345678901234567890aaaaaaaaaa"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
index e5080e902d6..97ebfa046e4 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
@@ -51,7 +51,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
@@ -75,7 +74,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
index 38f8c53d800..3c55a421f43 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
@@ -102,7 +102,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), 0, 0, S());
@@ -127,7 +126,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
     }
-#endif
     {
     typedef std::string S;
     test_npos(S(), S(), 0, S());
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
index 64befe456e5..08cefeae6ca 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
@@ -53,7 +53,6 @@ int main(int, char**)
     test(S("12345678901234567890"), SV("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
@@ -78,7 +77,6 @@ int main(int, char**)
     test(S("12345678901234567890"), SV("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
index d385e16c704..622f691230f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
@@ -102,7 +102,6 @@ int main(int, char**)
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("6789012345"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
@@ -128,7 +127,6 @@ int main(int, char**)
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("6789012345"));
     }
-#endif
     {
     typedef std::string S;
     typedef std::string_view SV;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
index 1abcca387f2..ffc10e432e3 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -113,9 +113,7 @@ void test_string() {
 
 bool test() {
   test_string<std::string>();
-#if TEST_STD_VER >= 2011
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
-#endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
index 930195fd41b..9555aa8ba24 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890",
          S("12345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", S());
@@ -59,7 +58,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890",
          S("12345678901234567890"));
     }
-#endif
 
     { // test assignment to self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
index 1e3592c4cc9..fa91da4c1d8 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("12345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", 0, S());
@@ -68,7 +67,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("12345678901234567890"));
     }
-#endif
     { // test assign to self
     typedef std::string S;
     S s_short = "123/";
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
index fbd6bc1fe58..aa2939ee0e2 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
@@ -52,7 +52,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("12345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
@@ -76,7 +75,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("12345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
index 145ec2c7dbb..23a8606fd63 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
     test(S("12345678901234567890"), 1, 'a', S(1, 'a'));
     test(S("12345678901234567890"), 10, 'a', S(10, 'a'));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, 'a', S());
@@ -59,7 +58,6 @@ int main(int, char**)
     test(S("12345678901234567890"), 1, 'a', S(1, 'a'));
     test(S("12345678901234567890"), 10, 'a', S(10, 'a'));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
index 0f5a4e7a588..fe09fd3c8a8 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
@@ -77,7 +77,6 @@ int main(int, char**)
     testAlloc(S(A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7));
     }
 
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
@@ -106,7 +105,6 @@ int main(int, char**)
     testAlloc(S(), S("1234567890"), min_allocator<char>());
     testAlloc(S(), S("12345678901234567890"), min_allocator<char>());
     }
-#endif
 #if TEST_STD_VER > 2014
     {
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
index 4f244cd2428..147cdbbc522 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
@@ -102,7 +102,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("6789012345"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), 0, 0, S());
@@ -127,7 +126,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("6789012345"));
     }
-#endif
     {
     typedef std::string S;
     test_npos(S(), S(), 0, S());
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
index 8ae0a7dd5f6..8d3552ef4c7 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
@@ -70,7 +70,6 @@ int main(int, char**)
     testAlloc(S(), SV("12345678901234567890"), std::allocator<char>());
     }
 
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
@@ -100,7 +99,6 @@ int main(int, char**)
     testAlloc(S(), SV("1234567890"), min_allocator<char>());
     testAlloc(S(), SV("12345678901234567890"), min_allocator<char>());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
index c3267466062..cb9bf644031 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
@@ -118,7 +118,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), s, 20, 1);
     test(S("abcdefghijklmnopqrst"), s, 21, 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     char s[50];
@@ -181,7 +180,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), s, 20, 1);
     test(S("abcdefghijklmnopqrst"), s, 21, 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
index 118b17c03b6..f2de2a474a3 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 10, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("abcde"), 0, S("bcde"));
@@ -61,7 +60,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 10, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
index 7839f37705e..a4444fe9fe0 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
@@ -88,7 +88,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, S(""));
@@ -146,7 +145,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
index 737e26e3cef..e5f8ae16822 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
@@ -34,14 +34,12 @@ int main(int, char**)
     test(S("abcdefghij"), S("abcdefghi"));
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("abcde"), S("abcd"));
     test(S("abcdefghij"), S("abcdefghi"));
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
index 6b92f23ce55..4d04f7b2cb7 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
@@ -198,7 +198,6 @@ int main(int, char**)
     test(S("abcdefghij"), S(""));
     test(S("abcdefghijklmnopqrst"), S(""));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, S(""));
@@ -302,7 +301,6 @@ int main(int, char**)
     test(S("abcdefghij"), S(""));
     test(S("abcdefghijklmnopqrst"), S(""));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
index 3fe94e279cb..b67a7ab08b2 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
@@ -52,7 +52,6 @@ int main(int, char**)
     test(s, s.begin()+5, 'B', S("a567AB1432dcb"));
     test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
@@ -71,7 +70,6 @@ int main(int, char**)
     test(s, s.begin()+5, 'B', S("a567AB1432dcb"));
     test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
index 7efe08ebcc2..f7a70452385 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -104,9 +104,7 @@ void test_string() {
 
 bool test() {
   test_string<std::string>();
-#if TEST_STD_VER >= 2011
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
-#endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
index 2499a80db07..ed1238a2b0e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
@@ -97,7 +97,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 20, 10, '1', S("abcdefghijklmnopqrst1111111111"));
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, '1', S(""));
@@ -165,7 +164,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 20, 10, '1', S("abcdefghijklmnopqrst1111111111"));
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
index 5e70924ad05..4c837524487 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
@@ -1771,7 +1771,6 @@ int main(int, char**)
     test29<S, SV>();
     test30<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -1807,7 +1806,6 @@ int main(int, char**)
     test29<S, SV>();
     test30<S, SV>();
     }
-#endif
     {
     typedef std::string S;
     typedef std::string_view SV;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
index 222d3907342..95bef31e982 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -137,7 +137,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", S("can't happen"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, "", S(""));
@@ -221,7 +220,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", S("can't happen"));
     }
-#endif
 
     { // test inserting into self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
index 7e3baa9d3b3..97653a91463 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -378,7 +378,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 20, S("can't happen"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, "", 0, S(""));
@@ -702,7 +701,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 20, S("can't happen"));
     }
-#endif
 
     { // test inserting into self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
index d537535b7e3..ed4688962e7 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
@@ -138,7 +138,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, 10, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 20, '1', S("can't happen"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, '1', S(""));
@@ -222,7 +221,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, 10, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 20, '1', S("can't happen"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
index 42fbf3e4153..ac93419006b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
@@ -137,7 +137,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), S("can't happen"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, S(""), S(""));
@@ -221,7 +220,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), S("can't happen"));
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
index c6729c66958..35d44a9bf08 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
@@ -1768,7 +1768,6 @@ int main(int, char**)
     test29<S>();
     test30<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -1803,7 +1802,6 @@ int main(int, char**)
     test29<S>();
     test30<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
index f858a0a3f77..1677195b983 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -138,7 +138,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
@@ -223,7 +222,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
     }
-#endif
 
     { // test inserting into self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
index 791c4e93a76..9a4af498689 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
     test(S("1234567890"), 'a', S("1234567890a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a', S("a"));
@@ -42,7 +41,6 @@ int main(int, char**)
     test(S("1234567890"), 'a', S("1234567890a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
index d5cd8ff9c53..c50f60fa18a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
@@ -50,7 +50,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", S());
@@ -74,7 +73,6 @@ int main(int, char**)
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
index 6e7b95ea543..0b69b7ea38b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
@@ -51,7 +51,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
@@ -75,7 +74,6 @@ int main(int, char**)
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
index 8b65d806327..890b446629b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -1073,9 +1073,7 @@ void test() {
 int main(int, char**)
 {
   test<std::string>();
-#if TEST_STD_VER >= 2011
   test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
index 4ca92cc87ef..1338dceee5f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
@@ -274,14 +274,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
     { // test replacing into self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
index 7fe8ddbc726..6105a0aed2d 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -957,7 +957,6 @@ int main(int, char**)
     test7<S>();
     test8<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -970,7 +969,6 @@ int main(int, char**)
     test7<S>();
     test8<S>();
     }
-#endif
 
     { // test replacing into self
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
index b4faab9b5e7..aebb1377b03 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
@@ -273,14 +273,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
index 219f43e355b..96a3b52901a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
@@ -272,14 +272,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
index ebde957ac7c..566bd3886f9 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
@@ -273,7 +273,6 @@ int main(int, char**)
     test1<S, SV>();
     test2<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
@@ -281,7 +280,6 @@ int main(int, char**)
     test1<S, SV>();
     test2<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
index 6ac1675a6f3..4bcb79856fc 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
@@ -5936,7 +5936,6 @@ int main(int, char**)
     test54<S, SV>();
     test55<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -5997,7 +5996,6 @@ int main(int, char**)
     test54<S, SV>();
     test55<S, SV>();
     }
-#endif
     {
     typedef std::string S;
     typedef std::string_view SV;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
index 2984307809b..6933279b486 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
@@ -376,14 +376,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
index bde1c84177e..98f6c0be894 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
@@ -1319,7 +1319,6 @@ int main(int, char**)
     test10<S>();
     test11<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -1335,7 +1334,6 @@ int main(int, char**)
     test10<S>();
     test11<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
index a014918cc88..4120925e962 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
@@ -377,14 +377,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
index aef22c1d130..843cc353981 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
@@ -375,14 +375,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
index b7b51cd681f..cfe34df3a72 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -5925,7 +5925,6 @@ int main(int, char**)
     test54<S>();
     test55<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -5985,7 +5984,6 @@ int main(int, char**)
     test54<S>();
     test55<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
index c911a784930..59274c06fda 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
@@ -376,7 +376,6 @@ int main(int, char**)
     test1<S, SV>();
     test2<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
@@ -384,7 +383,6 @@ int main(int, char**)
     test1<S, SV>();
     test2<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
index de72e0e5482..f353bb9706e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
@@ -52,7 +52,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""));
@@ -72,7 +71,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
index 2175cff1942..873aeb0f473 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
@@ -48,7 +48,6 @@ int main(int, char**)
         assert(in.eof());
         assert(s == L"   ghij");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::istringstream in(" abc\n  def\n   ghij");
@@ -77,7 +76,6 @@ int main(int, char**)
         assert(in.eof());
         assert(s == L"   ghij");
     }
-#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::basic_stringbuf<char> sb("hello");
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
index 139c9c9929a..1ee1a2aaa56 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
@@ -54,7 +54,6 @@ int main(int, char**)
         assert(in.eof());
         assert(s == L"   ghij");
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::istringstream in(" abc*  def**   ghij");
@@ -89,7 +88,6 @@ int main(int, char**)
         assert(in.eof());
         assert(s == L"   ghij");
     }
-#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::basic_stringbuf<char> sb("hello");
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
index c8ad93f710e..9fd6f32fa4a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
@@ -104,7 +104,6 @@ int main(int, char**)
         assert(threw);
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
-#if TEST_STD_VER >= 2011
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::istringstream in("a bc defghij");
@@ -151,7 +150,6 @@ int main(int, char**)
         in >> s;
         assert(in.fail());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
index c06b1433294..b7b1d32c27c 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
@@ -52,7 +52,6 @@ int main(int, char**)
         assert(out.good());
         assert(L"   " + s == out.str());
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
         std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
@@ -87,7 +86,6 @@ int main(int, char**)
         assert(out.good());
         assert(L"   " + s == out.str());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
index e842c1e3926..239c399382c 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
@@ -54,7 +54,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""));
@@ -74,7 +73,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
index 5d0318b670c..c530771b98e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
@@ -65,7 +64,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
index a2febddaf40..c6e6b7747f4 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
@@ -65,7 +64,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
index eeb2e43e6dd..b061fff2b94 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
index cffa004939c..4412a71bd10 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
index c6b299f426b..e938a8271bb 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
index a96ef402b4a..6ed30c3420a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
@@ -28,12 +28,10 @@ void test0(typename S::value_type lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
-#if TEST_STD_VER >= 2011
 template <class S>
 void test1(typename S::value_type lhs, S&& rhs, const S& x) {
   assert(lhs + std::move(rhs) == x);
 }
-#endif
 
 int main(int, char**) {
   {
@@ -43,7 +41,6 @@ int main(int, char**) {
     test0('a', S("1234567890"), S("a1234567890"));
     test0('a', S("12345678901234567890"), S("a12345678901234567890"));
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::string S;
     test1('a', S(""), S("a"));
@@ -65,7 +62,6 @@ int main(int, char**) {
     test1('a', S("1234567890"), S("a1234567890"));
     test1('a', S("12345678901234567890"), S("a12345678901234567890"));
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
index f7b65ebd759..7b6442e2247 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
@@ -28,12 +28,10 @@ void test0(const typename S::value_type* lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
-#if TEST_STD_VER >= 2011
 template <class S>
 void test1(const typename S::value_type* lhs, S&& rhs, const S& x) {
   assert(lhs + std::move(rhs) == x);
 }
-#endif
 
 int main(int, char**) {
   {
@@ -59,7 +57,6 @@ int main(int, char**) {
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 
-#if TEST_STD_VER >= 2011
   {
     typedef std::string S;
     test1("", S(""), S(""));
@@ -126,7 +123,6 @@ int main(int, char**) {
     test1("abcdefghijklmnopqrst", S("12345678901234567890"),
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
index 3ef17eeee80..a3f7d7a2ed1 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
@@ -28,12 +28,10 @@ void test0(const S& lhs, typename S::value_type rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
-#if TEST_STD_VER >= 2011
 template <class S>
 void test1(S&& lhs, typename S::value_type rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
-#endif
 
 int main(int, char**) {
   {
@@ -43,7 +41,6 @@ int main(int, char**) {
     test0(S("abcdefghij"), '1', S("abcdefghij1"));
     test0(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::string S;
     test1(S(""), '1', S("1"));
@@ -65,7 +62,6 @@ int main(int, char**) {
     test1(S("abcdefghij"), '1', S("abcdefghij1"));
     test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
index a308e12e6d7..9977833a47f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
@@ -28,12 +28,10 @@ void test0(const S& lhs, const typename S::value_type* rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
-#if TEST_STD_VER >= 2011
 template <class S>
 void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
-#endif
 
 int main(int, char**) {
   {
@@ -58,7 +56,6 @@ int main(int, char**) {
     test0(S("abcdefghijklmnopqrst"), "12345678901234567890",
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::string S;
     test1(S(""), "", S(""));
@@ -125,7 +122,6 @@ int main(int, char**) {
     test1(S("abcdefghijklmnopqrst"), "12345678901234567890",
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
index 22c6b9ad6ab..bbbea56238f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
@@ -40,7 +40,6 @@ void test0(const S& lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
-#if TEST_STD_VER >= 2011
 template <class S>
 void test1(S&& lhs, const S& rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
@@ -56,7 +55,6 @@ void test3(S&& lhs, S&& rhs, const S& x) {
   assert(std::move(lhs) + std::move(rhs) == x);
 }
 
-#endif
 
 int main(int, char**) {
   {
@@ -83,7 +81,6 @@ int main(int, char**) {
     test0(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::string S;
     test1(S(""), S(""), S(""));
@@ -244,7 +241,6 @@ int main(int, char**) {
     test3(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
index 04566c13877..759c2ce2938 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
@@ -65,7 +64,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
index fd7ab1619d1..ce56504a0db 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
@@ -65,7 +64,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
index 7217009c2d5..7d411355bec 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
index c57dafccf5f..734d6231f62 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
index 8cf0f94dd86..22b2a5c2495 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
index c8591a3bab6..a1feaa4c76a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
@@ -65,7 +64,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
index 17cffc32a9d..73118914503 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
@@ -65,7 +64,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
index 8aa2169b35f..0ec751f6f93 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
index f6a42a0729f..74c64beb122 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
index 48ff510dc20..29723a669f0 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
index 80e0e62db69..6d0ce64923d 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
@@ -65,7 +64,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
index 926a7b3364b..bba9bf672a8 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
@@ -65,7 +64,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
index 606e65e7bc0..8f4d328d479 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
index 8512205b02f..08f4d6d4263 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
index 22814d6538c..601ae8646ba 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
index 4295ef13285..2d38c9e7ada 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
@@ -65,7 +64,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
index bfc0adcf888..86fc209511b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
@@ -65,7 +64,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
index a7ec67728d9..9e97a4b5913 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
index 113b23bda9b..70cd5108152 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
index 82357b6bb4a..f63efdb68f9 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
index e32c8796e8a..63f0cbd062d 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
@@ -65,7 +64,6 @@ int main(int, char**)
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
index c46393cbdd0..a4a531d60cf 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
@@ -65,7 +64,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
index 53b88efc306..4d93c993cc8 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
index bf71dcb736b..20a0c51130f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
index ef2028788b1..e5b2be87fba 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -66,7 +65,6 @@ int main(int, char**)
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
index 4bb557957bf..2a2c59aeb47 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
     test(S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""));
@@ -48,7 +47,6 @@ int main(int, char**)
     test(S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
index cd3eef1bde8..30ff579f829 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**)
     test_const(S("abcdefghij"));
     test_const(S("abcdefghijklmnopqrst"));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test_const(S(""));
@@ -64,7 +63,6 @@ int main(int, char**)
     test_const(S("abcdefghij"));
     test_const(S("abcdefghijklmnopqrst"));
     }
-#endif
 #if TEST_STD_VER > 2014
     {
     typedef std::string S;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
index 7dc0b05b246..68518e683c3 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
@@ -34,7 +34,6 @@ int main(int, char**)
     test(S("abcdefghij", A(2)), A(2));
     test(S("abcdefghijklmnopqrst", A(3)), A(3));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -43,7 +42,6 @@ int main(int, char**)
     test(S("abcdefghij", A()), A());
     test(S("abcdefghijklmnopqrst", A()), A());
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
index 4f505a6154d..2072f907946 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
@@ -53,7 +53,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", 0);
@@ -73,7 +72,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
index 1873c20cb8e..98a2f524911 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
@@ -5902,7 +5902,6 @@ int main(int, char**)
     test54<S, SV>();
     test55<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
@@ -5963,7 +5962,6 @@ int main(int, char**)
     test54<S, SV>();
     test55<S, SV>();
     }
-#endif
     {
     typedef std::string S;
     typedef std::string_view SV;
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
index 84b0ad17ce2..df1351feaba 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -374,14 +374,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
index 1e943d8df31..af9cd83853c 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -1316,7 +1316,6 @@ int main(int, char**)
     test10<S>();
     test11<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -1332,7 +1331,6 @@ int main(int, char**)
     test10<S>();
     test11<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
index 52bf8f881fa..d0cf1987841 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -373,14 +373,12 @@ int main(int, char**)
     test1<S>();
     test2<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
index 926a68ed5d5..5e142f216b9 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -5902,7 +5902,6 @@ int main(int, char**)
     test54<S>();
     test55<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -5962,7 +5961,6 @@ int main(int, char**)
     test54<S>();
     test55<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
index 4f11e8d37a4..fcd534b6588 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -375,7 +375,6 @@ int main(int, char**)
     test1<S, SV>();
     test2<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
@@ -383,7 +382,6 @@ int main(int, char**)
     test1<S, SV>();
     test2<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
index e5722e97bd2..41b564019b1 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
@@ -53,7 +53,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), 0);
@@ -73,7 +72,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 0);
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
index bf87d71ed85..7468e247093 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
@@ -54,7 +54,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
@@ -75,7 +74,6 @@ int main(int, char**)
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
index e9739a34d9f..a0ea8948742 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
@@ -67,7 +67,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'q', 0);
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'q', 0, S::npos);
@@ -98,7 +97,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'q', 0);
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
index 9cc378b5bf3..bb31677ff84 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
@@ -148,13 +148,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
index a3d3434c3eb..6b28a50458f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
@@ -375,7 +375,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -383,7 +382,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
index 4d609a0f4a1..bf7ebb6fcb9 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
@@ -147,13 +147,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
index d838d38f748..32907737c79 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
@@ -148,14 +148,12 @@ int main(int, char**)
     test0<S, SV>();
     test1<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
index bf07cdb8e9f..0798a4e24bb 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'e', S::npos);
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'e', 0, S::npos);
@@ -94,7 +93,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'e', S::npos);
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
index 06a5b88b40b..43524df523f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
@@ -148,13 +148,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
index 5cad0fac14e..d550b63ece0 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
@@ -375,7 +375,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -383,7 +382,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
index eb7615bd32b..af5b2d43375 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
@@ -147,13 +147,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
index 13b107da5c8..8e6e09ebdac 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
@@ -148,14 +148,12 @@ int main(int, char**)
     test0<S, SV>();
     test1<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
index a6973db9e2f..e4d26a6ad4a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'i', 9);
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'i', 0, S::npos);
@@ -94,7 +93,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'i', 9);
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
index d90542839a4..17638139aac 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
@@ -148,13 +148,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
index 59d0369bac3..88e98073f6e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
@@ -375,7 +375,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -383,7 +382,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
index 2e3a3d03241..c9968c8524f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
@@ -147,13 +147,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
index 61353b05574..be560efd61e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
@@ -148,14 +148,12 @@ int main(int, char**)
     test0<S, SV>();
     test1<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
 //     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
 //     typedef std::string_view SV;
 //     test0<S, SV>();
 //     test1<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
index f5994e6295e..d433fc5129c 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'm', 3);
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'm', 0, S::npos);
@@ -94,7 +93,6 @@ int main(int, char**)
     test(S("gfsmthlkon"), 'm', 3);
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
index 1e0cbbc61ce..4568a9bdf7a 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
@@ -148,13 +148,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
index 86f28a5370e..f88194a089e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
@@ -375,7 +375,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -383,7 +382,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
index 72cecb21910..486dd909a29 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
@@ -147,13 +147,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
index 8b57985f71e..25dfcce31c3 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
@@ -148,14 +148,12 @@ int main(int, char**)
     test0<S, SV>();
     test1<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
index 7e489e8da34..1a17cbd758b 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     test(S("abcdeabcde"), 'c', 2);
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'c', 0, S::npos);
@@ -94,7 +93,6 @@ int main(int, char**)
     test(S("abcdeabcde"), 'c', 2);
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
index 1916af849ab..c1a64fed416 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
@@ -154,13 +154,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
index ba13da07bdf..084c5eed0ee 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
@@ -375,7 +375,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -383,7 +382,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
index ddd8bba0156..aa42d21d492 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
@@ -147,13 +147,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
index e03e89f4f9a..a347de4799c 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
@@ -148,14 +148,12 @@ int main(int, char**)
     test0<S, SV>();
     test1<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
index 3a1e2d760c1..79734595d0f 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     test(S("abcdeabcde"), 'b', 6);
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'b', 0, S::npos);
@@ -94,7 +93,6 @@ int main(int, char**)
     test(S("abcdeabcde"), 'b', 6);
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
index 1a8ca8560a4..c8548354ccc 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
@@ -155,13 +155,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
index a47261f8fa7..5adfe59a3c2 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
@@ -375,7 +375,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
@@ -383,7 +382,6 @@ int main(int, char**)
     test2<S>();
     test3<S>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
index f8da9b8b102..c376e613973 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
@@ -147,13 +147,11 @@ int main(int, char**)
     test0<S>();
     test1<S>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     }
-#endif
 
 #if TEST_STD_VER > 3
     {   // LWG 2946
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
index df85931fef6..5fcda86696e 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
@@ -148,14 +148,12 @@ int main(int, char**)
     test0<S, SV>();
     test1<S, SV>();
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
index 3d9ff56290c..5ca9f67d537 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
@@ -115,7 +115,6 @@ int main(int, char**)
     test(S("lsaijeqhtrbgcdmpfkno"), 20, 0);
     test(S("dplqartnfgejichmoskb"), 21, 0);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0);
@@ -177,7 +176,6 @@ int main(int, char**)
     test(S("lsaijeqhtrbgcdmpfkno"), 20, 0);
     test(S("dplqartnfgejichmoskb"), 21, 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
index 37e2d465688..51c3e2c78a3 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
@@ -41,7 +41,6 @@ int main(int, char**)
     test_contiguous(S("1", A(5)));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
     }
-#if TEST_STD_VER >= 2011
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -49,7 +48,6 @@ int main(int, char**)
     test_contiguous(S("1", A()));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/basic.string/types.pass.cpp b/libcudacxx/libcxx/test/std/strings/basic.string/types.pass.cpp
index 3f0d4800896..fb452f7c233 100644
--- a/libcudacxx/libcxx/test/std/strings/basic.string/types.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/basic.string/types.pass.cpp
@@ -79,9 +79,7 @@ int main(int, char**)
                                 std::char_traits<char> >::value), "");
     static_assert((std::is_same<std::basic_string<char>::allocator_type,
                                 std::allocator<char> >::value), "");
-#if TEST_STD_VER >= 2011
     test<std::char_traits<char>, min_allocator<char> >();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
index 8d99bd25329..50e029350b7 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
@@ -30,11 +30,9 @@ constexpr bool test_constexpr()
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     char16_t c = u'\0';
     std::char_traits<char16_t>::assign(c, u'a');
     assert(c == u'a');
-#endif
 
 #if TEST_STD_VER > 2014
     static_assert(test_constexpr(), "" );
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
index f8f280a1fca..65366080c6c 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
@@ -31,7 +31,6 @@ constexpr bool test_constexpr()
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char16_t>::compare(u"", u"", 0) == 0);
     assert(std::char_traits<char16_t>::compare(NULL, NULL, 0) == 0);
 
@@ -52,7 +51,6 @@ int main(int, char**)
     assert(std::char_traits<char16_t>::compare(u"223", u"123", 3) > 0);
     assert(std::char_traits<char16_t>::compare(u"133", u"123", 3) > 0);
     assert(std::char_traits<char16_t>::compare(u"124", u"123", 3) > 0);
-#endif
 
 #if TEST_STD_VER > 2014
     static_assert(test_constexpr(), "" );
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
index c9b8b35c3d7..4de51616a1c 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char16_t>::eq(u'a', u'a'));
     assert(!std::char_traits<char16_t>::eq(u'a', u'A'));
-#endif
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
index 9c8132aee40..b8d47febf3c 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
@@ -20,11 +20,9 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert( std::char_traits<char16_t>::eq_int_type(u'a', u'a'));
     assert(!std::char_traits<char16_t>::eq_int_type(u'a', u'A'));
     assert(!std::char_traits<char16_t>::eq_int_type(std::char_traits<char16_t>::eof(), u'A'));
-#endif
     assert( std::char_traits<char16_t>::eq_int_type(std::char_traits<char16_t>::eof(),
                                                     std::char_traits<char16_t>::eof()));
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
index ca164c4c85f..2c71eb6a2b3 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
@@ -29,13 +29,11 @@ constexpr bool test_constexpr()
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char16_t>::length(u"") == 0);
     assert(std::char_traits<char16_t>::length(u"a") == 1);
     assert(std::char_traits<char16_t>::length(u"aa") == 2);
     assert(std::char_traits<char16_t>::length(u"aaa") == 3);
     assert(std::char_traits<char16_t>::length(u"aaaa") == 4);
-#endif
 
 #if TEST_STD_VER > 2014
     static_assert(test_constexpr(), "" );
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
index 6575048b957..2b155b9ade7 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(!std::char_traits<char16_t>::lt(u'a', u'a'));
     assert( std::char_traits<char16_t>::lt(u'A', u'a'));
-#endif
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
index 8aadd5f041a..fbdfea90306 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char16_t>::not_eof(u'a') == u'a');
     assert(std::char_traits<char16_t>::not_eof(u'A') == u'A');
-#endif
     assert(std::char_traits<char16_t>::not_eof(0) == 0);
     assert(std::char_traits<char16_t>::not_eof(std::char_traits<char16_t>::eof()) !=
            std::char_traits<char16_t>::eof());
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
index 53c573873c9..41b30bf6566 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char16_t>::to_char_type(u'a') == u'a');
     assert(std::char_traits<char16_t>::to_char_type(u'A') == u'A');
-#endif
     assert(std::char_traits<char16_t>::to_char_type(0) == 0);
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
index 6d1f16ef62e..5c6242771d8 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char16_t>::to_int_type(u'a') == u'a');
     assert(std::char_traits<char16_t>::to_int_type(u'A') == u'A');
-#endif
     assert(std::char_traits<char16_t>::to_int_type(0) == 0);
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
index fcf5169877a..3f2e6070db1 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
@@ -30,11 +30,9 @@ constexpr bool test_constexpr()
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     char32_t c = U'\0';
     std::char_traits<char32_t>::assign(c, U'a');
     assert(c == U'a');
-#endif
 
 #if TEST_STD_VER > 2014
     static_assert(test_constexpr(), "" );
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
index f7d769c01b3..00b9a8c4bba 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
@@ -30,7 +30,6 @@ constexpr bool test_constexpr()
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char32_t>::compare(U"", U"", 0) == 0);
     assert(std::char_traits<char32_t>::compare(NULL, NULL, 0) == 0);
 
@@ -51,7 +50,6 @@ int main(int, char**)
     assert(std::char_traits<char32_t>::compare(U"223", U"123", 3) > 0);
     assert(std::char_traits<char32_t>::compare(U"133", U"123", 3) > 0);
     assert(std::char_traits<char32_t>::compare(U"124", U"123", 3) > 0);
-#endif
 
 #if TEST_STD_VER > 2014
     static_assert(test_constexpr(), "" );
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
index 9a92c1ce4c8..ce8c03135c7 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char32_t>::eq(U'a', U'a'));
     assert(!std::char_traits<char32_t>::eq(U'a', U'A'));
-#endif
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
index 983f07b0395..7aa18d97fa6 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
@@ -20,11 +20,9 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert( std::char_traits<char32_t>::eq_int_type(U'a', U'a'));
     assert(!std::char_traits<char32_t>::eq_int_type(U'a', U'A'));
     assert(!std::char_traits<char32_t>::eq_int_type(std::char_traits<char32_t>::eof(), U'A'));
-#endif
     assert( std::char_traits<char32_t>::eq_int_type(std::char_traits<char32_t>::eof(),
                                                     std::char_traits<char32_t>::eof()));
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
index 1bd7366f038..9b69fce9c21 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
@@ -29,13 +29,11 @@ constexpr bool test_constexpr()
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char32_t>::length(U"") == 0);
     assert(std::char_traits<char32_t>::length(U"a") == 1);
     assert(std::char_traits<char32_t>::length(U"aa") == 2);
     assert(std::char_traits<char32_t>::length(U"aaa") == 3);
     assert(std::char_traits<char32_t>::length(U"aaaa") == 4);
-#endif
 
 #if TEST_STD_VER > 2014
     static_assert(test_constexpr(), "" );
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
index 76e3b046e28..1b53e3596a8 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(!std::char_traits<char32_t>::lt(U'a', U'a'));
     assert( std::char_traits<char32_t>::lt(U'A', U'a'));
-#endif
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
index d4ee21fbbc5..4181e8e0fcb 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char32_t>::not_eof(U'a') == U'a');
     assert(std::char_traits<char32_t>::not_eof(U'A') == U'A');
-#endif
     assert(std::char_traits<char32_t>::not_eof(0) == 0);
     assert(std::char_traits<char32_t>::not_eof(std::char_traits<char32_t>::eof()) !=
            std::char_traits<char32_t>::eof());
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
index 0411227c0ac..ebe21b040c1 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char32_t>::to_char_type(U'a') == U'a');
     assert(std::char_traits<char32_t>::to_char_type(U'A') == U'A');
-#endif
     assert(std::char_traits<char32_t>::to_char_type(0) == 0);
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
diff --git a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
index 22abc411a28..8d2e006f28d 100644
--- a/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
@@ -20,10 +20,8 @@
 int main(int, char**)
 {
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 2011
     assert(std::char_traits<char32_t>::to_int_type(U'a') == U'a');
     assert(std::char_traits<char32_t>::to_int_type(U'A') == U'A');
-#endif
     assert(std::char_traits<char32_t>::to_int_type(0) == 0);
 #endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
 
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/at.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/at.pass.cpp
index b560b7e98f9..c0a8472e31e 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/at.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/at.pass.cpp
@@ -43,22 +43,18 @@ int main(int, char**) {
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
-#endif
 
-#if TEST_STD_VER >= 2011
     {
     constexpr std::basic_string_view<char> sv ( "ABC", 2 );
     static_assert ( sv.length() ==  2,  "" );
     static_assert ( sv.at(0) == 'A', "" );
     static_assert ( sv.at(1) == 'B', "" );
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/back.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/back.pass.cpp
index f05a02ce265..dd3b575ca30 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/back.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/back.pass.cpp
@@ -34,21 +34,17 @@ int main(int, char**) {
     assert ( test ( L"ABCDE", 5 ));
     assert ( test ( L"a", 1 ));
 
-#if TEST_STD_VER >= 2011
     assert ( test ( u"ABCDE", 5 ));
     assert ( test ( u"a", 1 ));
 
     assert ( test ( U"ABCDE", 5 ));
     assert ( test ( U"a", 1 ));
-#endif
 
-#if TEST_STD_VER >= 2011
     {
     constexpr std::basic_string_view<char> sv ( "ABC", 2 );
     static_assert ( sv.length() ==  2,  "" );
     static_assert ( sv.back()  == 'B', "" );
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/data.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/data.pass.cpp
index ab256334ca3..414bed8c476 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/data.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/data.pass.cpp
@@ -34,13 +34,11 @@ int main(int, char**) {
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/front.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/front.pass.cpp
index 254c004c65f..591c097e698 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/front.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/front.pass.cpp
@@ -34,21 +34,17 @@ int main(int, char**) {
     assert ( test ( L"ABCDE", 5 ));
     assert ( test ( L"a", 1 ));
 
-#if TEST_STD_VER >= 2011
     assert ( test ( u"ABCDE", 5 ));
     assert ( test ( u"a", 1 ));
 
     assert ( test ( U"ABCDE", 5 ));
     assert ( test ( U"a", 1 ));
-#endif
 
-#if TEST_STD_VER >= 2011
     {
     constexpr std::basic_string_view<char> sv ( "ABC", 2 );
     static_assert ( sv.length() ==  2,  "" );
     static_assert ( sv.front()  == 'A', "" );
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/index.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/index.pass.cpp
index abe888c44ec..4d769ca432e 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/index.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.access/index.pass.cpp
@@ -36,13 +36,11 @@ int main(int, char**) {
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
index 8ba67d42d80..482d744fb87 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
@@ -88,7 +88,6 @@ int main(int, char**) {
     test2 ( u8"", 0 );
 #endif
 
-#if TEST_STD_VER >= 2011
     test2 ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
     test2 ( u"ABCDE", 5 );
     test2 ( u"a", 1 );
@@ -98,7 +97,6 @@ int main(int, char**) {
     test2 ( U"ABCDE", 5 );
     test2 ( U"a", 1 );
     test2 ( U"", 0 );
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/assign.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/assign.pass.cpp
index 75cc1f94a92..89237083cb8 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/assign.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/assign.pass.cpp
@@ -35,11 +35,9 @@ int main(int, char**) {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert( test<std::u8string_view>  (u8"1234"));
 #endif
-#if TEST_STD_VER >= 2011
 #ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
     assert( test<std::u16string_view> ( u"1234"));
     assert( test<std::u32string_view> ( U"1234"));
-#endif
 #endif
     assert( test<std::wstring_view>   ( L"1234"));
 
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
index 1a230fbd4a9..ca0c3c23b79 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
@@ -49,7 +49,6 @@ int main(int, char**) {
     test ( L"A" );
     test ( L"" );
 
-#if TEST_STD_VER >= 2011
     test ( u"QBCDE" );
     test ( u"A" );
     test ( u"" );
@@ -57,7 +56,6 @@ int main(int, char**) {
     test ( U"QBCDE" );
     test ( U"A" );
     test ( U"" );
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
index c316fa481f7..c6512ba5eee 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
@@ -57,7 +57,6 @@ int main(int, char**) {
     }
 #endif
 
-#if TEST_STD_VER >= 2011
     test ( u"QBCDE", 5 );
     test ( u"QBCDE", 2 );
     test ( u"", 0 );
@@ -68,7 +67,6 @@ int main(int, char**) {
     static_assert ( sv1.size() == 2, "" );
     static_assert ( sv1.data() == s, "" );
     }
-#endif
 
     test ( U"QBCDE", 5 );
     test ( U"QBCDE", 2 );
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_string.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
index 9b8720379e8..f1910622d48 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
@@ -47,7 +47,6 @@ int main(int, char**) {
     test ( std::u8string{} );
 #endif
 
-#if TEST_STD_VER >= 2011
     test ( std::u16string{u"QBCDE"} );
     test ( std::u16string{u""} );
     test ( std::u16string{} );
@@ -55,7 +54,6 @@ int main(int, char**) {
     test ( std::u32string{U"QBCDE"} );
     test ( std::u32string{U""} );
     test ( std::u32string{} );
-#endif
 
     test ( std::basic_string<char, dummy_char_traits>("QBCDE") );
     test ( std::basic_string<char, dummy_char_traits>("") );
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/begin.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
index 6074c50b23d..1454bfa979b 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
@@ -58,10 +58,8 @@ int main(int, char**)
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test(u8string_view{u8"123"});
 #endif
-#if TEST_STD_VER >= 2011
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/end.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/end.pass.cpp
index f039f509f84..612fe2a83a6 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/end.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/end.pass.cpp
@@ -67,10 +67,8 @@ int main(int, char**)
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test(u8string_view{u8"123"});
 #endif
-#if TEST_STD_VER >= 2011
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
index ac0603e38f8..c0d5f6cff56 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
@@ -59,10 +59,8 @@ int main(int, char**)
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test(u8string_view{u8"123"});
 #endif
-#if TEST_STD_VER >= 2011
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
-#endif
 
 #if TEST_STD_VER > 2014
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rend.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
index 6ef61b28329..66f2e6d8ba5 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
@@ -67,10 +67,8 @@ int main(int, char**)
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test(u8string_view{u8"123"});
 #endif
-#if TEST_STD_VER >= 2011
     test(u16string_view{u"123"});
     test(u32string_view{U"123"});
-#endif
 
 #if TEST_STD_VER > 2014
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
index 5824919272f..571ccfe6217 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
@@ -55,7 +55,6 @@ int main(int, char**) {
     test ( L"a", 1 );
     test ( L"", 0 );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
     test ( u"", 0 );
@@ -63,7 +62,6 @@ int main(int, char**) {
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
     test ( U"", 0 );
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
index 2dc62e42dc3..3a76165aad7 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
@@ -56,7 +56,6 @@ int main(int, char**) {
     test ( L"a", 1 );
     test ( L"", 0 );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
     test ( u"", 0 );
@@ -64,7 +63,6 @@ int main(int, char**) {
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
     test ( U"", 0 );
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
index e4fce2aeeb7..38d503ab45b 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
@@ -55,7 +55,6 @@ int main(int, char**) {
     test ( L"a", 1 );
     test ( L"", 0 );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
     test ( u"", 0 );
@@ -63,7 +62,6 @@ int main(int, char**) {
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
     test ( U"", 0 );
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
index 8327b9c73a3..e023fff992a 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
@@ -72,7 +72,6 @@ int main(int, char**)
     test(L"abcdefghijklmnopqrst", L"abcdefghijklmnopqrst", 0);
     }
 
-#if TEST_STD_VER >= 2011
     {
     test(U"", U"", 0);
     test(U"", U"abcde", -5);
@@ -110,7 +109,6 @@ int main(int, char**)
     test(u"abcdefghijklmnopqrst", u"abcdefghij", 10);
     test(u"abcdefghijklmnopqrst", u"abcdefghijklmnopqrst", 0);
     }
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
index a6681320b3a..88b628fe408 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
@@ -398,7 +398,6 @@ int main(int, char**)
     test(L"abcdefghijklmnopqrst", 0, static_cast<size_t>(-1), L"abcdefghijklmnopqrst", 0);
     }
 
-#if TEST_STD_VER >= 2011
     {
     test(U"", 0, 0, U"", 0);
     test(U"", 0, 0, U"abcde", -5);
@@ -436,7 +435,6 @@ int main(int, char**)
     test(u"abcdefghijklmnopqrst", 0, 12, u"abcdefghij", 10);
     test(u"abcdefghijklmnopqrst", 0, static_cast<size_t>(-1), u"abcdefghijklmnopqrst", 0);
     }
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
index dc372f020a8..9fcb42cb812 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
@@ -373,7 +373,6 @@ int main(int, char**) {
     test(L"ABCde", 2, 4, L"abcde", -1);
     }
 
-#if TEST_STD_VER >= 2011
     {
     test(u"abcde", 5, 1, u"", 0);
     test(u"abcde", 2, 4, u"", 3);
@@ -387,7 +386,6 @@ int main(int, char**) {
     test(U"abcde", 2, 4, U"abcde", 2);
     test(U"ABCde", 2, 4, U"abcde", -1);
     }
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
index fdff1b28985..51c329a4170 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
@@ -1321,7 +1321,6 @@ int main(int, char**) {
     test(L"abcdefghijklmnopqrst", 10, 0, L"abcdefghij", 10, -10);
     }
 
-#if TEST_STD_VER >= 2011
     {
     test(U"", 0, 0, U"abcde", 0, 0);
     test(U"", 0, 0, U"abcde", 1, -1);
@@ -1337,7 +1336,6 @@ int main(int, char**) {
     test(U"abcdefghijklmnopqrst", 21, 0, U"abcde", 1, 0);
     test(U"abcdefghijklmnopqrst", 10, 0, U"abcdefghij", 10, -10);
     }
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
index 1f06459448f..ac50a4570a0 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
@@ -5819,7 +5819,6 @@ int main(int, char**) {
     test(L"ABCde", 2, 4, L"abcde", 2, 4, -1);
     }
 
-#if TEST_STD_VER >= 2011
     {
     test(u"abcde", 5, 1, u"", 0, 0, 0);
     test(u"abcde", 2, 4, u"", 0, 0, 3);
@@ -5833,7 +5832,6 @@ int main(int, char**) {
     test(U"abcde", 2, 4, U"abcde", 3, 4, -2);
     test(U"ABCde", 2, 4, U"abcde", 2, 4, -1);
     }
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
index 596e8da3a8f..b1bfabd4668 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
@@ -70,7 +70,6 @@ int main(int, char**) {
     test(L"abcdefghijklmnopqrst", L"abcdefghij", 10);
     test(L"abcdefghijklmnopqrst", L"abcdefghijklmnopqrst", 0);
 
-#if TEST_STD_VER >= 2011
     test(u"",                     u"", 0);
     test(u"",                     u"abcde", -5);
     test(u"",                     u"abcdefghij", -10);
@@ -104,7 +103,6 @@ int main(int, char**) {
     test(U"abcdefghijklmnopqrst", U"abcde", 15);
     test(U"abcdefghijklmnopqrst", U"abcdefghij", 10);
     test(U"abcdefghijklmnopqrst", U"abcdefghijklmnopqrst", 0);
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp
index 8f90225a6de..8df6976c72b 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp
@@ -88,7 +88,6 @@ int main(int, char**) {
     test ( L"a" );
     test ( L"" );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
@@ -98,7 +97,6 @@ int main(int, char**) {
     test ( U"ABCDE" );
     test ( U"a" );
     test ( U"" );
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/substr.pass.cpp b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/substr.pass.cpp
index 3eecaf5bd4d..823d34e516f 100644
--- a/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/substr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/strings/string.view/string.view.ops/substr.pass.cpp
@@ -80,7 +80,6 @@ int main(int, char**) {
     test ( L"a" );
     test ( L"" );
 
-#if TEST_STD_VER >= 2011
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
@@ -90,7 +89,6 @@ int main(int, char**) {
     test ( U"ABCDE" );
     test ( U"a" );
     test ( U"" );
-#endif
 
 #if TEST_STD_VER > 2011
     {
diff --git a/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_assign.fail.cpp b/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
index fb96c7f6830..cfb18e2b433 100644
--- a/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
+++ b/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
@@ -20,7 +20,6 @@
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     {
         std::promise<int> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
@@ -33,20 +32,6 @@ int main(int, char**)
         std::promise<void> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
-#else
-    {
-        std::promise<int> p0, p;
-        p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<int>'}}
-    }
-    {
-        std::promise<int&> p0, p;
-        p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<int &>'}}
-    }
-    {
-        std::promise<void> p0, p;
-        p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<void>'}}
-    }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp b/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
index 11b210d33b5..147859c4960 100644
--- a/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
+++ b/libcudacxx/libcxx/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
@@ -20,7 +20,6 @@
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     {
         std::promise<int> p0;
         std::promise<int> p(p0); // expected-error {{call to deleted constructor of 'std::promise<int>'}}
@@ -33,20 +32,6 @@ int main(int, char**)
         std::promise<void> p0;
         std::promise<void> p(p0); // expected-error {{call to deleted constructor of 'std::promise<void>'}}
     }
-#else
-    {
-        std::promise<int> p0;
-        std::promise<int> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<int>'}}
-    }
-    {
-        std::promise<int &> p0;
-        std::promise<int &> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<int &>'}}
-    }
-    {
-        std::promise<void> p0;
-        std::promise<void> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<void>'}}
-    }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp b/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
index 6e502245f19..4bf66418f2a 100644
--- a/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
+++ b/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
@@ -20,7 +20,6 @@
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     {
         std::future<int> f0, f;
         f = f0; // expected-error {{overload resolution selected deleted operator '='}}
@@ -33,20 +32,5 @@ int main(int, char**)
         std::future<void> f0, f;
         f = f0; // expected-error {{overload resolution selected deleted operator '='}}
     }
-#else
-    {
-        std::future<int> f0, f;
-        f = f0; // expected-error {{'operator=' is a private member of 'std::__1::future<int>'}}
-    }
-    {
-        std::future<int &> f0, f;
-        f = f0; // expected-error {{'operator=' is a private member of 'std::__1::future<int &>'}}
-    }
-    {
-        std::future<void> f0, f;
-        f = f0; // expected-error {{'operator=' is a private member of 'std::__1::future<void>'}}
-    }
-#endif
-
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp b/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
index 1d3d9ffa296..b26d6d138a0 100644
--- a/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
+++ b/libcudacxx/libcxx/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
@@ -20,7 +20,6 @@
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     {
         std::future<int> f0;
         std::future<int> f = f0; // expected-error {{call to deleted constructor of 'std::future<int>'}}
@@ -33,20 +32,6 @@ int main(int, char**)
         std::future<void> f0;
         std::future<void> f = f0; // expected-error {{call to deleted constructor of 'std::future<void>'}}
     }
-#else
-    {
-        std::future<int> f0;
-        std::future<int> f = f0; // expected-error {{calling a private constructor of class 'std::__1::future<int>'}}
-    }
-    {
-        std::future<int &> f0;
-        std::future<int &> f = f0; // expected-error {{calling a private constructor of class 'std::__1::future<int &>'}}
-    }
-    {
-        std::future<void> f0;
-        std::future<void> f = f0; // expected-error {{calling a private constructor of class 'std::__1::future<void>'}}
-    }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
index 524810b5d4d..78bbf7cc9bc 100644
--- a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
+++ b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
@@ -187,7 +187,6 @@ int main(int, char**)
         }
     }
 #endif
-#if TEST_STD_VER >= 2011
     {
         L0 l0;
         L0 l1;
@@ -517,7 +516,6 @@ int main(int, char**)
         }
     }
 #endif  // TEST_HAS_NO_EXCEPTIONS
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
index 968fa2dda82..1525032b045 100644
--- a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
+++ b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
@@ -125,7 +125,6 @@ int main(int, char**)
         }
     }
 #endif
-#if TEST_STD_VER >= 2011
     {
         L0 l0;
         L0 l1;
@@ -521,7 +520,6 @@ int main(int, char**)
         assert(!l2.locked());
         assert(!l3.locked());
     }
-#endif  // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
index 272d2aa37c3..b81adce6951 100644
--- a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
+++ b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
@@ -65,7 +65,6 @@ void f3()
 #endif
 }
 
-#if TEST_STD_VER >= 2011
 
 struct init1
 {
@@ -100,7 +99,6 @@ void f2()
     std::call_once(flg2, init2(), 4, 5);
 }
 
-#endif  // TEST_STD_VER >= 2011
 
 std::once_flag flg41;
 std::once_flag flg42;
@@ -134,7 +132,6 @@ void f42()
     std::call_once(flg41, init41);
 }
 
-#if TEST_STD_VER >= 2011
 
 class MoveOnly
 {
@@ -184,8 +181,6 @@ struct RefQual
     void operator()() && { ++rv_called; }
 };
 
-#endif // TEST_STD_VER >= 2011
-
 int main(int, char**)
 {
     // check basic functionality
@@ -216,7 +211,6 @@ int main(int, char**)
         assert(init41_called == 1);
         assert(init42_called == 1);
     }
-#if TEST_STD_VER >= 2011
     // check functors with 1 arg
     {
         std::thread t0(f1);
@@ -252,7 +246,6 @@ int main(int, char**)
         std::call_once(f2, std::move(rq));
         assert(rq.rv_called == 1);
     }
-#endif  // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
index d5b66d49849..34d5985f9b4 100644
--- a/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
@@ -21,12 +21,10 @@ int main(int, char**)
     std::once_flag f;
     (void)f;
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::once_flag f;
     (void)f;
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp b/libcudacxx/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
index afb413bc58d..288484294b4 100644
--- a/libcudacxx/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
+++ b/libcudacxx/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
@@ -85,7 +85,6 @@ class G
 int G::n_alive = 0;
 bool G::op_run = false;
 
-#if TEST_STD_VER >= 2011
 
 class MoveOnly
 {
@@ -99,7 +98,6 @@ class MoveOnly
     }
 };
 
-#endif
 
 // Test throwing std::bad_alloc
 //-----------------------------
@@ -192,7 +190,6 @@ int main(int, char**)
         }
     }
 #endif
-#if TEST_STD_VER >= 2011
     {
         assert(G::n_alive == 0);
         assert(!G::op_run);
@@ -208,7 +205,6 @@ int main(int, char**)
         std::thread t = std::thread(MoveOnly(), MoveOnly());
         t.join();
     }
-#endif
 
     return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
index e2082e9d12d..8fbdde6b238 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
@@ -31,7 +31,6 @@ test(const T& t)
     static_assert(std::is_nothrow_move_constructible<T>::value, "");
 }
 
-#if TEST_STD_VER >= 2011
 constexpr decltype(std::placeholders::_1)  default1{};
 constexpr decltype(std::placeholders::_2)  default2{};
 constexpr decltype(std::placeholders::_3)  default3{};
@@ -53,10 +52,8 @@ constexpr decltype(std::placeholders::_7)  cp7 = std::placeholders::_7;
 constexpr decltype(std::placeholders::_8)  cp8 = std::placeholders::_8;
 constexpr decltype(std::placeholders::_9)  cp9 = std::placeholders::_9;
 constexpr decltype(std::placeholders::_10) cp10 = std::placeholders::_10;
-#endif // TEST_STD_VER >= 2011
 
 void use_placeholders_to_prevent_unused_warning() {
-#if TEST_STD_VER >= 2011
   ((void)cp1);
   ((void)cp2);
   ((void)cp3);
@@ -77,7 +74,6 @@ void use_placeholders_to_prevent_unused_warning() {
   ((void)default8);
   ((void)default9);
   ((void)default10);
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
index e2e600e81c0..b63d70cefbb 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
@@ -70,9 +70,7 @@ int main(int, char**)
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
-#if TEST_STD_VER >= 2011
     static_assert((noexcept(std::mem_fn(&A::test0))), ""); // LWG#2489
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
index 51402ae90be..f9fad5214f2 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
@@ -63,9 +63,7 @@ int main(int, char**)
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = A(2);
-#if TEST_STD_VER >= 2011
     static_assert(noexcept(swap(f1, f2)), "" );
-#endif
     assert(A::count == 2);
     assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f1.target<A>()->id() == 1);
@@ -81,9 +79,7 @@ int main(int, char**)
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = g;
-#if TEST_STD_VER >= 2011
     static_assert(noexcept(swap(f1, f2)), "" );
-#endif
     assert(A::count == 1);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f1.target<A>()->id() == 1);
@@ -99,9 +95,7 @@ int main(int, char**)
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = A(1);
-#if TEST_STD_VER >= 2011
     static_assert(noexcept(swap(f1, f2)), "" );
-#endif
     assert(A::count == 1);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(*f1.target<int(*)(int)>() == g);
@@ -117,9 +111,7 @@ int main(int, char**)
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = h;
-#if TEST_STD_VER >= 2011
     static_assert(noexcept(swap(f1, f2)), "" );
-#endif
     assert(A::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(*f1.target<int(*)(int)>() == g);
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
index 6b1f6770b2e..7e26f03d077 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
@@ -49,7 +49,6 @@ int A::count = 0;
 
 int g(int) {return 0;}
 
-#if TEST_STD_VER >= 2011
 struct RValueCallable {
     template <class ...Args>
     void operator()(Args&&...) && {}
@@ -58,7 +57,6 @@ struct LValueCallable {
     template <class ...Args>
     void operator()(Args&&...) & {}
 };
-#endif
 
 int main(int, char**)
 {
@@ -102,7 +100,6 @@ int main(int, char**)
         std::function <void()> f(static_cast<void (*)()>(0));
         assert(!f);
     }
-#if TEST_STD_VER >= 2011
     {
         using Fn = std::function<void(int, int, int)>;
         static_assert(std::is_constructible<Fn, LValueCallable&>::value, "");
@@ -110,7 +107,6 @@ int main(int, char**)
         static_assert(!std::is_constructible<Fn, RValueCallable&>::value, "");
         static_assert(!std::is_constructible<Fn, RValueCallable>::value, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
index 1ee7a8e00f1..4ad59f3cd99 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
@@ -52,7 +52,6 @@ int A::count = 0;
 
 int g(int) {return 0;}
 
-#if TEST_STD_VER >= 2011
 struct RValueCallable {
     template <class ...Args>
     void operator()(Args&&...) && {}
@@ -61,7 +60,6 @@ struct LValueCallable {
     template <class ...Args>
     void operator()(Args&&...) & {}
 };
-#endif
 
 int main(int, char**)
 {
@@ -106,7 +104,6 @@ int main(int, char**)
     assert(f.target<int(*)(int)>() != 0);
     f(1);
     }
-#if TEST_STD_VER >= 2011
     {
         using Fn = std::function<void(int, int, int)>;
         static_assert(std::is_assignable<Fn&, LValueCallable&>::value, "");
@@ -114,7 +111,6 @@ int main(int, char**)
         static_assert(!std::is_assignable<Fn&, RValueCallable&>::value, "");
         static_assert(!std::is_assignable<Fn&, RValueCallable>::value, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
index d948f21f0cb..db7e586be37 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
@@ -113,7 +113,6 @@ struct MemFun03 {
     int foo(int, int, int, ...) const volatile { return 42; }
 };
 
-#if TEST_STD_VER >= 2011
 struct MemFun11 {
     int foo() & { return 42; }
     int foo() const & { return 42; }
@@ -135,7 +134,6 @@ struct MemFun11 {
     int foo(...) volatile && { return 42; }
     int foo(...) const volatile && { return 42; }
 };
-#endif // TEST_STD_VER >= 2011
 
 struct MemData {
     int foo;
@@ -214,7 +212,6 @@ void test_mf() {
     test_imp<int(MemFun03::*)(int, int) const volatile, int(MemFun03&, int, int)>();
     test_imp<int(MemFun03::*)(int, int, ...) const volatile, int(MemFun03&, int, int)>();
 
-#if TEST_STD_VER >= 2011
     test_imp<int(MemFun11::*)() &, int(MemFun11&)>();
     test_imp<int(MemFun11::*)(...) &, int(MemFun11&)>();
     test_imp<int(MemFun11::*)() const &, int(MemFun11&)>();
@@ -232,7 +229,6 @@ void test_mf() {
     test_imp<int(MemFun11::*)(...) volatile &&, int(MemFun11&&)>();
     test_imp<int(MemFun11::*)() const volatile &&, int(MemFun11&&)>();
     test_imp<int(MemFun11::*)(...) const volatile &&, int(MemFun11&&)>();
-#endif
 }
 
 void test_md() {
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
index e89952d2676..d78e2aec717 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
@@ -23,7 +23,6 @@
 #include "../function_types.h"
 
 
-#if TEST_STD_VER >= 2011
 struct RValueCallable {
     template <class ...Args>
     void operator()(Args&&...) && {}
@@ -32,7 +31,6 @@ struct LValueCallable {
     template <class ...Args>
     void operator()(Args&&...) & {}
 };
-#endif
 
 class DummyClass {};
 
@@ -118,7 +116,6 @@ int main(int, char**)
         non_default_test_allocator<DummyClass> non_default_alloc(42);
         test_for_alloc(non_default_alloc);
     }
-#if TEST_STD_VER >= 2011
     {
         using Fn = std::function<void(int, int, int)>;
         static_assert(std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, LValueCallable&>::value, "");
@@ -126,7 +123,6 @@ int main(int, char**)
         static_assert(!std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, RValueCallable&>::value, "");
         static_assert(!std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, RValueCallable>::value, "");
     }
-#endif
 
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
index f66ed41dbc3..0a185c3593a 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
@@ -116,7 +116,6 @@ int main(int, char**) {
     assert(&fr == &f);
     assert(*f.target<int(*)(int, int, int)>() == g3);
   }
-#if TEST_STD_VER >= 2011
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f = A();
@@ -133,7 +132,6 @@ int main(int, char**) {
     assert(f.target<A>() == 0);
     assert(f.target<int (*)(int)>() == 0);
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
index 248e7137047..09889cf8d24 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
@@ -100,7 +100,6 @@ int main(int, char**)
     assert(g.target<A>() == 0);
     assert(!g);
     }
-#if TEST_STD_VER >= 2011
     assert(globalMemCounter.checkOutstandingNewEq(0));
     { // Test rvalue references
         std::function<int(int)> f = A();
@@ -160,7 +159,6 @@ int main(int, char**)
         assert(f2.target<Ptr>());
         LIBCPP_ASSERT(f.target<Ptr>()); // f is unchanged because the target is small
     }
-#endif  // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
index ad50fa89fda..04ea5bbda62 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
@@ -62,7 +62,6 @@ int main(int, char**)
     const int j = 0;
     test(j);
 
-#if TEST_STD_VER >= 2011
     convertible_to_int_ref convi;
     test(convi);
     convertible_to_int_ref const convic;
@@ -74,7 +73,6 @@ int main(int, char**)
     static_assert((!std::is_assignable<Ref&, int>::value), "");
     static_assert((!std::is_assignable<Ref&, int&&>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
index 0141dbdd282..e62e2b8ed31 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
@@ -51,14 +51,12 @@ int main(int, char**)
     static_assert((!std::is_constructible<Ref, int&&>::value), "");
     }
 
-#if TEST_STD_VER >= 2011
     {
     using Ref = std::reference_wrapper<int>;
     static_assert((std::is_nothrow_constructible<Ref, int&>::value), "");
     static_assert((!std::is_nothrow_constructible<Ref, int>::value), "");
     static_assert((!std::is_nothrow_constructible<Ref, int&&>::value), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp b/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
index 114f7cf713a..5c59aec54d9 100644
--- a/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
@@ -19,7 +19,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
 class MoveOnly
 {
     MoveOnly(const MoveOnly&);
@@ -35,7 +34,6 @@ class MoveOnly
 
     int get() const {return data_;}
 };
-#endif
 
 
 template <class T>
@@ -54,9 +52,7 @@ int main(int, char**)
     test<int>();
     test<double>();
     test<std::string>();
-#if TEST_STD_VER >= 2011
     test<MoveOnly>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
index 046df33c799..62669087b1b 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
@@ -55,7 +55,6 @@ struct B
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
   {
     A<int> a;
     assert(std::allocator_traits<A<int> >::allocate(a, 10, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
@@ -66,7 +65,6 @@ int main(int, char**)
     Alloc a;
     assert(std::allocator_traits<Alloc >::allocate(a, 10, nullptr) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
   }
-#endif
   {
     B<int> b;
     assert(std::allocator_traits<B<int> >::allocate(b, 11, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
index 224f9860dd7..d4ea54f05c6 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
@@ -38,14 +38,12 @@ struct B
 {
     typedef T value_type;
 
-#if TEST_STD_VER >= 2011
     template <class U, class ...Args>
     void construct(U* p, Args&& ...args)
     {
         ++b_construct;
         ::new ((void*)p) U(std::forward<Args>(args)...);
     }
-#endif
 };
 
 struct A0
@@ -114,7 +112,6 @@ int main(int, char**)
       std::aligned_storage<sizeof(VT)>::type store;
       std::allocator_traits<Alloc>::construct(a, (VT*)&store, nullptr);
     }
-#if TEST_STD_VER >= 2011
     {
         A0::count = 0;
         b_construct = 0;
@@ -148,7 +145,6 @@ int main(int, char**)
         assert(A2::count == 1);
         assert(b_construct == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
index da46117968d..6a72f507cfa 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
@@ -72,7 +72,6 @@ int main(int, char**)
       std::aligned_storage<sizeof(VT)>::type store;
       std::allocator_traits<Alloc>::destroy(a, (VT*)&store);
     }
-#if defined(_LIBCUDACXX_VERSION) || TEST_STD_VER >= 2011
     {
         A0::count = 0;
         b_destroy = 0;
@@ -85,7 +84,6 @@ int main(int, char**)
         assert(A0::count == 1);
         assert(b_destroy == 1);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
index f4f6cf67833..c422da97d28 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
@@ -58,7 +58,6 @@ int main(int, char**)
         Alloc a;
         assert(std::allocator_traits<Alloc >::max_size(a) == 100);
     }
-#if TEST_STD_VER >= 2011
     {
         A<int> a;
         assert(std::allocator_traits<A<int> >::max_size(a) ==
@@ -73,7 +72,6 @@ int main(int, char**)
         std::allocator<int> a;
         static_assert(noexcept(std::allocator_traits<std::allocator<int>>::max_size(a)) == true, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
index 28dca4df4a7..e5e2b49c089 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
@@ -63,7 +63,6 @@ int main(int, char**)
         Alloc a;
         assert(std::allocator_traits<Alloc>::select_on_container_copy_construction(a).id == 0);
     }
-#if TEST_STD_VER >= 2011
     {
         B<int> b;
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
@@ -72,7 +71,6 @@ int main(int, char**)
         const B<int> b(0);
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
index 25d55ce0c3b..bb540db1ec8 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
@@ -60,9 +60,7 @@ int main(int, char**)
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_pointer, Ptr<const char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_pointer, const char*>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::const_pointer, CPtr<const char> >::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<D<char> >::const_pointer, const char*>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
index 2032a32832e..e95c19cf01a 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
@@ -62,9 +62,7 @@ int main(int, char**)
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_void_pointer, Ptr<const void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_void_pointer, const void*>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::const_void_pointer, CPtr<const void> >::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<D<char> >::const_void_pointer, const void*>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
index d31148d6da1..768034c7110 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
@@ -71,9 +71,7 @@ int main(int, char**)
     static_assert((std::is_same<std::allocator_traits<A<char> >::difference_type, short>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::difference_type, signed char>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<D<char> >::difference_type, std::ptrdiff_t>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
index ee3df7a1ade..a78fd62efba 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
@@ -47,9 +47,7 @@ int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::pointer, Ptr<char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::pointer, char*>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<C<char> >::pointer, char*>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
index 94f1cf1d566..3d566dfbe8b 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
@@ -47,9 +47,7 @@ int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_copy_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
index 311e0742e53..c5275c600ae 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
@@ -48,9 +48,7 @@ int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_move_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
index dfa977890a5..bdb2a522fd1 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
@@ -46,9 +46,7 @@ int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_swap, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_swap, std::false_type>::value), "");
- #if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_swap, std::false_type>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
index 2049ca19ff0..c0d6b9283f6 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
@@ -82,7 +82,6 @@ struct G {
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_alloc<double>, ReboundA<double> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_alloc<double>, ReboundB<double, char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_alloc<double>, C<double> >::value), "");
@@ -90,13 +89,6 @@ int main(int, char**)
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_alloc<double>, E<double> >::value), "");
     static_assert((std::is_same<std::allocator_traits<F<char> >::rebind_alloc<double>, F<double> >::value), "");
     static_assert((std::is_same<std::allocator_traits<G<char> >::rebind_alloc<double>, G<double> >::value), "");
-#else
-    static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_alloc<double>::other, ReboundA<double> >::value), "");
-    static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_alloc<double>::other, ReboundB<double, char> >::value), "");
-    static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_alloc<double>::other, C<double> >::value), "");
-    static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_alloc<double>::other, D<double, char> >::value), "");
-    static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_alloc<double>::other, E<double> >::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
index 64aaf561ef6..a266e316c87 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
@@ -69,9 +69,7 @@ int main(int, char**)
                    std::make_unsigned<std::ptrdiff_t>::type>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::size_type,
                    unsigned char>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<D<char> >::size_type, unsigned short>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
index 2afe2e2e783..13bf222970f 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
@@ -61,9 +61,7 @@ int main(int, char**)
     static_assert((std::is_same<std::allocator_traits<A<char> >::void_pointer, Ptr<void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::void_pointer, void*>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::void_pointer, CPtr<void> >::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<D<char> >::void_pointer, void*>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
index dd71c977fa8..414e29c8842 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
@@ -64,19 +64,11 @@ struct E
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_traits<double>, std::allocator_traits<ReboundA<double> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_traits<double>, std::allocator_traits<ReboundB<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_traits<double>, std::allocator_traits<C<double> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_traits<double>, std::allocator_traits<D<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_traits<double>, std::allocator_traits<E<double> > >::value), "");
-#else
-    static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_traits<double>::other, std::allocator_traits<ReboundA<double> > >::value), "");
-    static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_traits<double>::other, std::allocator_traits<ReboundB<double, char> > >::value), "");
-    static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_traits<double>::other, std::allocator_traits<C<double> > >::value), "");
-    static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_traits<double>::other, std::allocator_traits<D<double, char> > >::value), "");
-    static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_traits<double>::other, std::allocator_traits<E<double> > >::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
index 43f437cb505..d7ba2e73149 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
@@ -56,9 +56,7 @@ int main(int, char**)
     test<true, B, double>();
     test<false, C, decltype(C::allocator_type)>();
     test<false, D, decltype(D::allocator_type)>();
-#if TEST_STD_VER >= 2011
     test<false, E, int>();
-#endif
 
 
 //     static_assert((!std::uses_allocator<int, std::allocator<int> >::value), "");
@@ -68,9 +66,7 @@ int main(int, char**)
 //     static_assert(( std::uses_allocator<B, double>::value), "");
 //     static_assert((!std::uses_allocator<C, decltype(C::allocator_type)>::value), "");
 //     static_assert((!std::uses_allocator<D, decltype(D::allocator_type)>::value), "");
-// #if TEST_STD_VER >= 2011
 //     static_assert((!std::uses_allocator<E, int>::value), "");
-// #endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
index 03a33f19aa6..3412a2d57c2 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
@@ -34,7 +34,6 @@ struct A
 
 int move_only_constructed = 0;
 
-#if TEST_STD_VER >= 2011
 class move_only
 {
     move_only(const move_only&) = delete;
@@ -51,7 +50,6 @@ class move_only
     int data; // unused other than to make sizeof(move_only) == sizeof(int).
               // but public to suppress "-Wunused-private-field"
 };
-#endif // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -104,7 +102,6 @@ int main(int, char**)
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(A_constructed == 0);
     }
-#if TEST_STD_VER >= 2011
     {
     std::allocator<move_only> a;
     assert(globalMemCounter.checkOutstandingNewEq(0));
@@ -138,7 +135,6 @@ int main(int, char**)
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(move_only_constructed == 0);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
index 8d6c7f2eb2c..7bf1b12b864 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
@@ -59,9 +59,7 @@ int main(int, char**)
     static_assert((std::is_same<std::pointer_traits<C<double> >::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<std::pointer_traits<D<int> >::difference_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<E<int> >::difference_type, std::ptrdiff_t>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::pointer_traits<F<int>>::difference_type, std::ptrdiff_t>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
index 2e48adfd7e2..597a8b06da4 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
@@ -60,9 +60,7 @@ int main(int, char**)
     static_assert((std::is_same<std::pointer_traits<C<int> >::element_type, int>::value), "");
     static_assert((std::is_same<std::pointer_traits<D<double, int> >::element_type, double>::value), "");
     static_assert((std::is_same<std::pointer_traits<E<double, int> >::element_type, double>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::pointer_traits<F<double>>::element_type, double>::value), "");
-#endif
 
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
index fc211d9f4e9..0b23e4bcd87 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
@@ -30,11 +30,7 @@ template <class T> struct B1 {};
 template <class T>
 struct B
 {
-#if TEST_STD_VER >= 2011
     template <class U> using rebind = B1<U>;
-#else
-    template <class U> struct rebind {typedef B1<U> other;};
-#endif
 };
 
 template <class T, class U>
@@ -47,11 +43,7 @@ template <class T, class U> struct D1 {};
 template <class T, class U>
 struct D
 {
-#if TEST_STD_VER >= 2011
     template <class V> using rebind = D1<V, U>;
-#else
-    template <class V> struct rebind {typedef D1<V, U> other;};
-#endif
 };
 
 template <class T, class U>
@@ -62,14 +54,12 @@ struct E
 };
 
 
-#if TEST_STD_VER >= 2011
 template <class T, class U>
 struct F {
 private:
   template <class>
   using rebind = void;
 };
-#endif
 
 #if TEST_STD_VER >= 2014
 template <class T, class U>
@@ -83,7 +73,6 @@ struct G
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::pointer_traits<A<int*> >::rebind<double*>, A<double*> >::value), "");
     static_assert((std::is_same<std::pointer_traits<B<int> >::rebind<double>, B1<double> >::value), "");
     static_assert((std::is_same<std::pointer_traits<C<char, int> >::rebind<double>, C<double, int> >::value), "");
@@ -94,13 +83,5 @@ int main(int, char**)
 #if TEST_STD_VER >= 2014
     static_assert((std::is_same<std::pointer_traits<G<char, int> >::rebind<double>, G<double, int> >::value), "");
 #endif
-#else  // TEST_STD_VER < 2011
-    static_assert((std::is_same<std::pointer_traits<A<int*> >::rebind<double*>::other, A<double*> >::value), "");
-    static_assert((std::is_same<std::pointer_traits<B<int> >::rebind<double>::other, B1<double> >::value), "");
-    static_assert((std::is_same<std::pointer_traits<C<char, int> >::rebind<double>::other, C<double, int> >::value), "");
-    static_assert((std::is_same<std::pointer_traits<D<char, int> >::rebind<double>::other, D1<double, int> >::value), "");
-    static_assert((std::is_same<std::pointer_traits<E<char, int> >::rebind<double>::other, E<double, int> >::value), "");
-#endif
-
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/rebind.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
index a45e4de64fb..c68348c2537 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
@@ -22,11 +22,7 @@
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>, double*>::value), "");
-#else
-    static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>::other, double*>::value), "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
index af1a2f64dbd..04fe37e5e8a 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
@@ -15,12 +15,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 
 int A_constructed = 0;
 
@@ -34,7 +28,7 @@ struct A
     ~A() {--A_constructed; data_ = 0;}
 
     bool operator==(int i) const {return data_ == i;}
-    A* operator& () DELETE_FUNCTION;
+    A* operator& () = delete;
 };
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
index 977fa3a70bc..71365f5913a 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
@@ -17,12 +17,6 @@
 #include "test_macros.h"
 #include <MoveOnly.h>
 
-#if TEST_STD_VER >= 2011
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 int A_constructed = 0;
 
 struct A
@@ -35,7 +29,7 @@ struct A
     ~A() {--A_constructed; data_ = 0;}
 
     bool operator==(int i) const {return data_ == i;}
-    A* operator& () DELETE_FUNCTION;
+    A* operator& () = delete;
 };
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
index 191df9b670a..3263b87d306 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
@@ -19,13 +19,11 @@
 #include <memory>
 #include <cassert>
 
-#if TEST_STD_VER >= 2011
 #include "poisoned_hash_helper.h"
 
 #include "test_macros.h"
 
 struct A {};
-#endif
 
 int main(int, char**)
 {
@@ -36,12 +34,10 @@ int main(int, char**)
     std::size_t h = f(p);
     assert(h == std::hash<int*>()(ptr));
   }
-#if TEST_STD_VER >= 2011
   {
     test_hash_enabled_for_type<std::shared_ptr<int>>();
     test_hash_enabled_for_type<std::shared_ptr<A>>();
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
index 0f5153f3603..3f84c987bb8 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
@@ -21,7 +21,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
 #include "poisoned_hash_helper.h"
 #include "deleter_types.h"
 #include "min_allocator.h"
@@ -58,7 +57,6 @@ struct hash<::min_pointer<T, std::integral_constant<size_t, 1>>> {
 
 struct A {};
 
-#endif // TEST_STD_VER >= 2011
 
 int main(int, char**)
 {
@@ -69,7 +67,6 @@ int main(int, char**)
     std::size_t h = f(p);
     assert(h == std::hash<int*>()(ptr));
   }
-#if TEST_STD_VER >= 2011
   {
     std::unique_ptr<int, PointerDeleter<int, 1>> pThrowingHash;
     std::hash<std::unique_ptr<int, PointerDeleter<int, 1>>> fThrowingHash;
@@ -96,7 +93,6 @@ int main(int, char**)
     test_disabled_with_deleter<int[], PointerDeleter<int[], 0>>();
     test_disabled_with_deleter<A, PointerDeleter<A, 0>>();
     test_disabled_with_deleter<A[], PointerDeleter<A[], 0>>();
-#endif
   }
 #endif
 
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
index ac51ceef88b..4445a84eff1 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
@@ -49,11 +49,7 @@ int main(int, char**)
     {
         std::auto_ptr<A> ptr(new A);
         A* raw_ptr = ptr.get();
-#if TEST_STD_VER >= 2011
         std::shared_ptr<B> p(std::move(ptr));
-#else
-        std::shared_ptr<B> p(ptr);
-#endif
         assert(A::count == 1);
         assert(B::count == 1);
         assert(p.use_count() == 1);
@@ -69,27 +65,14 @@ int main(int, char**)
         globalMemCounter.throw_after = 0;
         try
         {
-#if TEST_STD_VER >= 2011
             std::shared_ptr<B> p(std::move(ptr));
-#else
-            std::shared_ptr<B> p(ptr);
-#endif
             assert(false);
         }
         catch (...)
         {
-#if TEST_STD_VER >= 2011
             assert(A::count == 1);
             assert(B::count == 1);
             assert(ptr.get() == raw_ptr);
- #else
-            // Without rvalue references, ptr got copied into
-            // the shared_ptr destructor and the copy was
-            // destroyed during unwinding.
-            (void) raw_ptr; // silence 'unused variable' warning
-            assert(A::count == 0);
-            assert(B::count == 0);
-#endif
         }
     }
     assert(A::count == 0);
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
index 665a796a98f..3eb06685e03 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
@@ -65,7 +65,6 @@ int main(int, char**)
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
     test_deleter<A>::dealloc_count = 0;
-#if TEST_STD_VER >= 2011
     // Test an allocator that returns class-type pointers
     {
     std::shared_ptr<A> p(nullptr, test_deleter<A>(1), min_allocator<void>());
@@ -81,7 +80,6 @@ int main(int, char**)
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
index 765eb6607c0..36a2e3e7be1 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
@@ -68,7 +68,6 @@ int main(int, char**)
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
     test_deleter<A>::dealloc_count = 0;
-#if TEST_STD_VER >= 2011
     // Test an allocator that returns class-type pointers
     {
     A* ptr = new A;
@@ -85,7 +84,6 @@ int main(int, char**)
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
index 41d17c93dab..3b8d44f5eb0 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
@@ -69,24 +69,13 @@ int main(int, char**)
             std::shared_ptr<B> pB(std::move(pA));
             assert(B::count == 1);
             assert(A::count == 1);
-#if TEST_STD_VER >= 2011
             assert(pB.use_count() == 1);
             assert(pA.use_count() == 0);
-#else
-            assert(pB.use_count() == 2);
-            assert(pA.use_count() == 2);
-#endif
             assert(p == pB.get());
         }
-#if TEST_STD_VER >= 2011
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
-#else
-        assert(pA.use_count() == 1);
-        assert(B::count == 1);
-        assert(A::count == 1);
-#endif
     }
     assert(B::count == 0);
     assert(A::count == 0);
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
index ca2fe0596a1..0e7f2beaaea 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
@@ -40,22 +40,12 @@ int main(int, char**)
             A* p = pA.get();
             std::shared_ptr<A> pA2(std::move(pA));
             assert(A::count == 1);
-#if TEST_STD_VER >= 2011
             assert(pA.use_count() == 0);
             assert(pA2.use_count() == 1);
-#else
-            assert(pA.use_count() == 2);
-            assert(pA2.use_count() == 2);
-#endif
             assert(pA2.get() == p);
         }
-#if TEST_STD_VER >= 2011
         assert(pA.use_count() == 0);
         assert(A::count == 0);
-#else
-        assert(pA.use_count() == 1);
-        assert(A::count == 1);
-#endif
     }
     assert(A::count == 0);
     {
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
index 087760daf25..cd2315d1030 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
@@ -74,17 +74,10 @@ int main(int, char**)
         }
         catch (...)
         {
-#if TEST_STD_VER >= 2011
             assert(A::count == 1);
             assert(B::count == 1);
             assert(ptr.get() == raw_ptr);
-#else
-            (void) raw_ptr; // silence 'unused variable' warning
-            assert(A::count == 0);
-            assert(B::count == 0);
-            assert(ptr.get() == 0);
-#endif
-        }
+       }
     }
 #endif
     assert(A::count == 0);
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
index 68f508c5f3b..f69cc4946bd 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
@@ -21,12 +21,6 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 int new_count = 0;
 
 struct A
@@ -42,7 +36,7 @@ struct A
     int get_int() const {return int_;}
     char get_char() const {return char_;}
 
-    A* operator& () DELETE_FUNCTION;
+    A* operator& () = delete;
 private:
     int int_;
     char char_;
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
index bace444280b..7c8676ed3d4 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
@@ -18,12 +18,6 @@
 #include "test_macros.h"
 #include "count_new.h"
 
-#if TEST_STD_VER >= 2011
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 struct A
 {
     static int count;
@@ -37,7 +31,7 @@ struct A
     int get_int() const {return int_;}
     char get_char() const {return char_;}
 
-    A* operator& () DELETE_FUNCTION;
+    A* operator& () = delete;
 
 private:
     int int_;
@@ -95,7 +89,6 @@ int main(int, char**)
 
     test_pointer_to_function();
 
-#if TEST_STD_VER >= 2011
     nc = globalMemCounter.outstanding_new;
     {
     char c = 'e';
@@ -105,7 +98,6 @@ int main(int, char**)
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');
     }
-#endif
     assert(A::count == 0);
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
index fa895074059..a4a091bb3c5 100644
--- a/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
@@ -56,10 +56,8 @@ int C::count = 0;
 template <class T>
 std::weak_ptr<T> source (std::shared_ptr<T> p) { return std::weak_ptr<T>(p); }
 
-#if TEST_STD_VER >= 2011
 template <class T>
 void sink (std::weak_ptr<T> &&) {}
-#endif
 
 int main(int, char**)
 {
@@ -101,7 +99,6 @@ int main(int, char**)
     assert(B::count == 0);
     assert(A::count == 0);
 
-#if TEST_STD_VER >= 2011
     {
         std::shared_ptr<A> ps(new A);
         std::weak_ptr<A> pA = source(ps);
@@ -111,7 +108,6 @@ int main(int, char**)
     }
     assert(B::count == 0);
     assert(A::count == 0);
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.help/integral_constant.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
index 33df6cdb4cf..8cb3b005175 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
@@ -21,9 +21,7 @@ int main(int, char**)
     static_assert(_5::value == 5, "");
     static_assert((std::is_same<_5::value_type, int>::value), "");
     static_assert((std::is_same<_5::type, _5>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((_5() == 5), "");
-#endif
     assert(_5() == 5);
 
 
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
index 5255421c9d5..1104b74c45f 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
@@ -62,26 +62,6 @@ namespace std
 
 template <class> struct VoidT { typedef void type; };
 
-#if TEST_STD_VER < 2011
-template <class Trait, class = void>
-struct no_common_type_imp : std::true_type {};
-
-template <class Trait>
-struct no_common_type_imp<Trait, typename VoidT<typename Trait::type>::type>
-    : std::false_type {};
-
-struct NoArgTag;
-
-template <class Tp = NoArgTag, class Up = NoArgTag, class Vp = NoArgTag>
-struct no_common_type : no_common_type_imp<std::common_type<Tp, Up, Vp> > {};
-template <class Tp, class Up>
-struct no_common_type<Tp, Up> : no_common_type_imp<std::common_type<Tp, Up> > {
-};
-template <class Tp>
-struct no_common_type<Tp> : no_common_type_imp<std::common_type<Tp> > {};
-template <>
-struct no_common_type<> : no_common_type_imp<std::common_type<> > {};
-#else
 template <class Tp>
 struct always_bool_imp { using type = bool; };
 template <class Tp> using always_bool = typename always_bool_imp<Tp>::type;
@@ -96,7 +76,6 @@ constexpr bool no_common_type_imp(long) { return true; }
 
 template <class ...Args>
 using no_common_type = std::integral_constant<bool, no_common_type_imp<Args...>(0)>;
-#endif
 
 template <class T1, class T2>
 struct TernaryOp {
@@ -259,10 +238,8 @@ void test_bullet_four() {
   { // test that there is no ::type member
     static_assert((no_common_type<int, E>::value), "");
     static_assert((no_common_type<int, int, E>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert((no_common_type<int, int, E, int>::value), "");
     static_assert((no_common_type<int, int, int, E>::value), "");
-#endif
   }
 }
 
@@ -350,10 +327,8 @@ int main(int, char**)
     static_assert((std::is_same<std::common_type<int, const int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<const int, const int>::type, int>::value), "");
 
-#if TEST_STD_VER >= 2011
     // Test that we're really variadic in C++11
     static_assert(std::is_same<std::common_type<int, int, int, int, int, int, int, int>::type, int>::value, "");
-#endif
 
 #if TEST_STD_VER > 2020
     // P2321
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
index 971875483af..be6fbd14049 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
@@ -88,9 +88,7 @@ struct test_invoke_no_result<Fn(Args...)>
 template <class T>
 void test_no_result()
 {
-#if TEST_STD_VER >= 2011
     static_assert((!HasType<std::result_of<T> >::value), "");
-#endif
 #if TEST_STD_VER > 2014
     test_invoke_no_result<T>::call();
 #endif
@@ -364,10 +362,8 @@ int main(int, char**)
     test_result_of<PMD(const SD*), const char&>();
     test_result_of<PMD(std::unique_ptr<S>), char &>();
     test_result_of<PMD(std::unique_ptr<S const>), const char&>();
-#if TEST_STD_VER >= 2011
     test_result_of<PMD(std::reference_wrapper<S>), char&>();
     test_result_of<PMD(std::reference_wrapper<S const>), const char&>();
-#endif
     test_no_result<PMD(ND&)>();
     }
 
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
index b395178a1d9..d3822218031 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
@@ -51,13 +51,11 @@ enum E { V = INT_MIN };
 enum F { W = UINT_MAX };
 #endif // TEST_UNSIGNED_UNDERLYING_TYPE
 
-#if TEST_STD_VER >= 2011
 enum G : char {};
 enum class H { red, green = 20, blue };
 enum class I : long { red, green = 20, blue };
 enum struct J { red, green = 20, blue };
 enum struct K : short { red, green = 20, blue };
-#endif
 
 int main(int, char**)
 {
@@ -68,13 +66,11 @@ int main(int, char**)
 #endif // TEST_UNSIGNED_UNDERLYING_TYPE
 
 //  Class enums and enums with specified underlying type
-#if TEST_STD_VER >= 2011
     check<G, char>();
     check<H, int>();
     check<I, long>();
     check<J, int>();
     check<K, short>();
-#endif
 
 //  SFINAE-able underlying_type
 #if TEST_STD_VER > 2017
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
index c3ead2579be..d7176072ff4 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
@@ -59,23 +59,19 @@ int main(int, char**)
 //  LWG 2101 specifically talks about add_pointer and functions.
 //  The term of art is "a referenceable type", which a cv- or ref-qualified function is not.
     test_function0<void()>();
-#if TEST_STD_VER >= 2011
     test_function1<void() const>();
     test_function1<void() &>();
     test_function1<void() &&>();
     test_function1<void() const &>();
     test_function1<void() const &&>();
-#endif
 
 //  But a cv- or ref-qualified member function *is* "a referenceable type"
     test_function0<void (Foo::*)()>();
-#if TEST_STD_VER >= 2011
     test_function0<void (Foo::*)() const>();
     test_function0<void (Foo::*)() &>();
     test_function0<void (Foo::*)() &&>();
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
index ebc8222008d..66764bfead5 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
@@ -16,11 +16,7 @@
 
 enum Enum {zero, one_};
 
-#if TEST_STD_VER >= 2011
 enum BigEnum : unsigned long long // MSVC's ABI doesn't follow the Standard
-#else
-enum BigEnum
-#endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
index e96dfd3bb20..952089d8c45 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
@@ -16,11 +16,7 @@
 
 enum Enum {zero, one_};
 
-#if TEST_STD_VER >= 2011
 enum BigEnum : unsigned long long // MSVC's ABI doesn't follow the Standard
-#else
-enum BigEnum
-#endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
index 3008f748761..5e6d648d7dd 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
@@ -18,11 +18,7 @@ using namespace std;
 class Class {};
 
 enum Enum1 {};
-#if TEST_STD_VER >= 2011
 enum class Enum2 : int {};
-#else
-enum Enum2 {};
-#endif
 
 template <class T>
 void test()
@@ -76,7 +72,6 @@ int main(int, char**)
     TEST_REGULAR( void (int, ...) );
     TEST_REGULAR( int (double, ...) );
     TEST_REGULAR( int (double, char, ...) );
-#if TEST_STD_VER >= 2011
     TEST_REF_QUALIFIED( void () );
     TEST_REF_QUALIFIED( void (int) );
     TEST_REF_QUALIFIED( int (double) );
@@ -85,7 +80,6 @@ int main(int, char**)
     TEST_REF_QUALIFIED( void (int, ...) );
     TEST_REF_QUALIFIED( int (double, ...) );
     TEST_REF_QUALIFIED( int (double, char, ...) );
-#endif
 
 //  LWG#2582
     static_assert(!std::is_function<incomplete_type>::value, "");
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
index 7e57bdb4a6e..51d40364fa0 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
@@ -78,16 +78,12 @@ int main(int, char**)
     test_is_class<Abstract>();
     test_is_class<incomplete_type>();
 
-#if TEST_STD_VER >= 2011
 // In C++03 we have an emulation of std::nullptr_t
     test_is_not_class<std::nullptr_t>();
-#endif
     test_is_not_class<void>();
     test_is_not_class<int>();
     test_is_not_class<int&>();
-#if TEST_STD_VER >= 2011
     test_is_not_class<int&&>();
-#endif
     test_is_not_class<int*>();
     test_is_not_class<double>();
     test_is_not_class<const int*>();
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
index b1ca88bd6ff..f08ad778498 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
@@ -101,10 +101,8 @@ int main(int, char**)
   test_is_not_function<Abstract*>();
   test_is_not_function<incomplete_type>();
 
-#if TEST_STD_VER >= 2011
   test_is_function<void() noexcept>();
   test_is_function<void() const && noexcept>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
index 2113292ecd0..d8d57f9b8fa 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
@@ -97,11 +97,9 @@ int main(int, char**)
     test_is_not_member_pointer<Abstract>();
     test_is_not_member_pointer<incomplete_type>();
 
-#if TEST_STD_VER >= 2011
   test_is_member_pointer<int (Empty::*)(int, ...) const>();
   test_is_member_pointer<int (Empty::*)(int, long, long) const noexcept>();
   test_is_member_pointer<int (Empty::*)() & noexcept>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
index 8d7690317c7..b62c173eb18 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
@@ -80,7 +80,6 @@ int main(int, char**)
 
 
 // reference qualifiers on functions are a C++11 extension
-#if TEST_STD_VER >= 2011
   // Noexcept qualifiers
   test_member_function_pointer<void (Class::*)() noexcept>();
   test_member_function_pointer<void (Class::*)(int) noexcept>();
@@ -221,7 +220,6 @@ int main(int, char**)
   test_member_function_pointer<void (Class::*)(...) const volatile && noexcept>();
   test_member_function_pointer<void (Class::*)(int,...) const volatile && noexcept>();
   test_member_function_pointer<void (Class::*)(int, char,...) const volatile && noexcept>();
-#endif
 
 //  LWG#2582
   static_assert(!std::is_member_function_pointer<incomplete_type>::value, "");
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
index 1dc08bfc1ae..b7bc8110b26 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -42,7 +42,6 @@ void test_is_not_assignable()
 
 struct D;
 
-#if TEST_STD_VER >= 2011
 struct C
 {
     template <class U>
@@ -53,7 +52,6 @@ struct E
 {
     C operator=(int);
 };
-#endif
 
 template <typename T>
 struct X { T t; };
@@ -66,12 +64,10 @@ int main(int, char**)
     test_is_assignable<B, A> ();
     test_is_assignable<void*&, void*> ();
 
-#if TEST_STD_VER >= 2011
     test_is_assignable<E, int> ();
 
     test_is_not_assignable<int, int&> ();
     test_is_not_assignable<int, int> ();
-#endif
     test_is_not_assignable<A, B> ();
     test_is_not_assignable<void, const void> ();
     test_is_not_assignable<const void, const void> ();
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
index db3dab34cd1..7b46a0d0050 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
@@ -18,21 +18,13 @@
 #include <type_traits>
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011 && defined(_LIBCUDACXX_VERSION)
-#define LIBCPP11_STATIC_ASSERT(...) static_assert(__VA_ARGS__)
-#else
-#define LIBCPP11_STATIC_ASSERT(...) ((void)0)
-#endif
-
 
 struct A
 {
     explicit A(int);
     A(int, double);
     A(int, long, double);
-#if TEST_STD_VER >= 2011
 private:
-#endif
     A(char);
 };
 
@@ -57,9 +49,7 @@ struct PrivateDtor {
 
 struct S {
    template <class T>
-#if TEST_STD_VER >= 2011
    explicit
-#endif
    operator T () const;
 };
 
@@ -68,19 +58,17 @@ struct ImplicitTo {
   operator To();
 };
 
-#if TEST_STD_VER >= 2011
 template <class To>
 struct ExplicitTo {
    explicit operator To ();
 };
-#endif
 
 
 template <class T>
 void test_is_constructible()
 {
     static_assert( (std::is_constructible<T>::value), "");
-    LIBCPP11_STATIC_ASSERT((std::__libcpp_is_constructible<T>::type::value), "");
+    static_assert((std::__libcpp_is_constructible<T>::type::value), "");
 #if TEST_STD_VER > 2014
     static_assert( std::is_constructible_v<T>, "");
 #endif
@@ -90,7 +78,7 @@ template <class T, class A0>
 void test_is_constructible()
 {
     static_assert(( std::is_constructible<T, A0>::value), "");
-    LIBCPP11_STATIC_ASSERT((std::__libcpp_is_constructible<T, A0>::type::value), "");
+    static_assert((std::__libcpp_is_constructible<T, A0>::type::value), "");
 #if TEST_STD_VER > 2014
     static_assert(( std::is_constructible_v<T, A0>), "");
 #endif
@@ -100,7 +88,7 @@ template <class T, class A0, class A1>
 void test_is_constructible()
 {
     static_assert(( std::is_constructible<T, A0, A1>::value), "");
-    LIBCPP11_STATIC_ASSERT((std::__libcpp_is_constructible<T, A0, A1>::type::value), "");
+    static_assert((std::__libcpp_is_constructible<T, A0, A1>::type::value), "");
 #if TEST_STD_VER > 2014
     static_assert(( std::is_constructible_v<T, A0, A1>), "");
 #endif
@@ -110,7 +98,7 @@ template <class T, class A0, class A1, class A2>
 void test_is_constructible()
 {
     static_assert(( std::is_constructible<T, A0, A1, A2>::value), "");
-    LIBCPP11_STATIC_ASSERT((std::__libcpp_is_constructible<T, A0, A1, A2>::type::value), "");
+    static_assert((std::__libcpp_is_constructible<T, A0, A1, A2>::type::value), "");
 #if TEST_STD_VER > 2014
     static_assert(( std::is_constructible_v<T, A0, A1, A2>), "");
 #endif
@@ -120,7 +108,7 @@ template <class T>
 void test_is_not_constructible()
 {
     static_assert((!std::is_constructible<T>::value), "");
-    LIBCPP11_STATIC_ASSERT((!std::__libcpp_is_constructible<T>::type::value), "");
+    static_assert((!std::__libcpp_is_constructible<T>::type::value), "");
 #if TEST_STD_VER > 2014
     static_assert((!std::is_constructible_v<T>), "");
 #endif
@@ -130,13 +118,12 @@ template <class T, class A0>
 void test_is_not_constructible()
 {
     static_assert((!std::is_constructible<T, A0>::value), "");
-    LIBCPP11_STATIC_ASSERT((!std::__libcpp_is_constructible<T, A0>::type::value), "");
+    static_assert((!std::__libcpp_is_constructible<T, A0>::type::value), "");
 #if TEST_STD_VER > 2014
     static_assert((!std::is_constructible_v<T, A0>), "");
 #endif
 }
 
-#if TEST_STD_VER >= 2011
 template <class T = int, class = decltype(static_cast<T&&>(std::declval<double&>()))>
 constexpr bool  clang_disallows_valid_static_cast_test(int) { return false; };
 
@@ -144,7 +131,6 @@ constexpr bool clang_disallows_valid_static_cast_test(long) { return true; }
 
 static constexpr bool clang_disallows_valid_static_cast_bug =
     clang_disallows_valid_static_cast_test(0);
-#endif
 
 
 int main(int, char**)
@@ -160,11 +146,7 @@ int main(int, char**)
     test_is_constructible<int&, int&> ();
 
     test_is_not_constructible<A> ();
-#if TEST_STD_VER >= 2011
     test_is_not_constructible<A, char> ();
-#else
-    test_is_constructible<A, char> ();
-#endif
     test_is_not_constructible<A, void> ();
     test_is_not_constructible<int, void()>();
     test_is_not_constructible<int, void(&)()>();
@@ -186,13 +168,10 @@ int main(int, char**)
 
     test_is_constructible<void(&)(), void(&)()>();
     test_is_constructible<void(&)(), void()>();
-#if TEST_STD_VER >= 2011
     test_is_constructible<void(&&)(), void(&&)()>();
     test_is_constructible<void(&&)(), void()>();
     test_is_constructible<void(&&)(), void(&)()>();
-#endif
 
-#if TEST_STD_VER >= 2011
     test_is_constructible<int const&, int>();
     test_is_constructible<int const&, int&&>();
 
@@ -214,7 +193,6 @@ int main(int, char**)
  && (!defined(TEST_COMPILER_CLANG) && __clang__ < 16))  \
  || TEST_STD_VER < 2020
     test_is_not_constructible<Derived&, Base&>();
-#endif
     test_is_constructible<Base const&, Derived const&>();
 #if (!defined(TEST_COMPILER_GCC)                        \
  && (!defined(TEST_COMPILER_CLANG) && __clang__ < 16))  \
@@ -316,7 +294,6 @@ int main(int, char**)
     test_is_not_constructible<void() &> ();
     test_is_not_constructible<void() &&> ();
 #endif
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
index d2a1e278b17..9ca0c5041d1 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
@@ -73,12 +73,10 @@ int main(int, char**)
     test_is_copy_assignable<NotEmpty> ();
     test_is_copy_assignable<Empty> ();
 
-#if TEST_STD_VER >= 2011
     test_is_not_copy_assignable<const int> ();
     test_is_not_copy_assignable<int[]> ();
     test_is_not_copy_assignable<int[3]> ();
     test_is_not_copy_assignable<B> ();
-#endif
     test_is_not_copy_assignable<void> ();
     test_is_not_copy_assignable<C> ();
 
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
index 5570901aa75..03cdd15c09c 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
@@ -90,9 +90,7 @@ int main(int, char**)
     test_is_not_copy_constructible<void>();
     test_is_not_copy_constructible<Abstract>();
     test_is_not_copy_constructible<C>();
-#if TEST_STD_VER >= 2011
     test_is_not_copy_constructible<B>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
index 54ded31d41c..410c6539db6 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
@@ -103,7 +103,6 @@ int main(int, char**)
 
     test_is_not_default_constructible<Abstract>();
     test_is_not_default_constructible<NoDefaultConstructor>();
-#if TEST_STD_VER >= 2011
     test_is_not_default_constructible<B>();
     test_is_not_default_constructible<int&&>();
 
@@ -120,7 +119,6 @@ int main(int, char**)
     test_is_not_default_constructible<void() volatile> ();
     test_is_not_default_constructible<void() &> ();
     test_is_not_default_constructible<void() &&> ();
-#endif
 #endif
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
index 3fe9f556f40..28e3898158f 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -86,7 +86,6 @@ struct PurePublicDestructor              { public:    virtual ~PurePublicDestruc
 struct PureProtectedDestructor           { protected: virtual ~PureProtectedDestructor() = 0; };
 struct PurePrivateDestructor             { private:   virtual ~PurePrivateDestructor() = 0; };
 
-#if TEST_STD_VER >= 2011
 struct DeletedPublicDestructor           { public:    ~DeletedPublicDestructor() = delete; };
 struct DeletedProtectedDestructor        { protected: ~DeletedProtectedDestructor() = delete; };
 struct DeletedPrivateDestructor          { private:   ~DeletedPrivateDestructor() = delete; };
@@ -94,7 +93,6 @@ struct DeletedPrivateDestructor          { private:   ~DeletedPrivateDestructor(
 struct DeletedVirtualPublicDestructor    { public:    virtual ~DeletedVirtualPublicDestructor() = delete; };
 struct DeletedVirtualProtectedDestructor { protected: virtual ~DeletedVirtualProtectedDestructor() = delete; };
 struct DeletedVirtualPrivateDestructor   { private:   virtual ~DeletedVirtualPrivateDestructor() = delete; };
-#endif
 
 
 int main(int, char**)
@@ -121,7 +119,6 @@ int main(int, char**)
     test_is_not_destructible<void>();
     test_is_not_destructible<Function>();
 
-#if TEST_STD_VER >= 2011
     // Test access controlled destructors
     test_is_not_destructible<ProtectedDestructor>();
     test_is_not_destructible<PrivateDestructor>();
@@ -140,7 +137,6 @@ int main(int, char**)
 
     // Test private destructors
     test_is_not_destructible<NotEmpty>();
-#endif
 
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
index 6e21cd52460..3dc99cc5141 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
@@ -72,9 +72,7 @@ typedef void (*FunctionPtr)();
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     test_is_literal_type<std::nullptr_t>();
-#endif
 
 // Before C++14, void was not a literal type
 // In C++14, cv-void is a literal type
@@ -88,9 +86,7 @@ int main(int, char**)
     test_is_literal_type<int*>();
     test_is_literal_type<const int*>();
     test_is_literal_type<int&>();
-#if TEST_STD_VER >= 2011
     test_is_literal_type<int&&>();
-#endif
     test_is_literal_type<double>();
     test_is_literal_type<char[3]>();
     test_is_literal_type<char[]>();
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
index 910c8053a7f..218aa2f4991 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
@@ -49,9 +49,7 @@ int main(int, char**)
 {
     test_is_nothrow_assignable<int&, int&> ();
     test_is_nothrow_assignable<int&, int> ();
-#if TEST_STD_VER >= 2011
     test_is_nothrow_assignable<int&, double> ();
-#endif
 
     test_is_not_nothrow_assignable<int, int&> ();
     test_is_not_nothrow_assignable<int, int> ();
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
index 86ee1e52275..954ef2e7a91 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
@@ -91,11 +91,9 @@ struct C
     void operator=(C&);  // not const
 };
 
-#if TEST_STD_VER >= 2011
 struct Tuple {
     Tuple(Empty&&) noexcept {}
 };
-#endif
 
 int main(int, char**)
 {
@@ -108,12 +106,10 @@ int main(int, char**)
     test_is_not_nothrow_constructible<A, int, double> ();
     test_is_not_nothrow_constructible<A> ();
     test_is_not_nothrow_constructible<C> ();
-#if TEST_STD_VER >= 2011
     test_is_nothrow_constructible<Tuple &&, Empty> (); // See bug #19616.
 
     static_assert(!std::is_constructible<Tuple&, Empty>::value, "");
     test_is_not_nothrow_constructible<Tuple &, Empty> (); // See bug #19616.
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
index b5022d6bd28..745937b51ca 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
@@ -59,22 +59,18 @@ struct A
     A();
 };
 
-#if TEST_STD_VER >= 2011
 struct DThrows
 {
     DThrows()  noexcept(true) {}
     ~DThrows() noexcept(false) {}
 };
-#endif
 
 int main(int, char**)
 {
     test_has_not_nothrow_default_constructor<void>();
     test_has_not_nothrow_default_constructor<int&>();
     test_has_not_nothrow_default_constructor<A>();
-#if TEST_STD_VER >= 2011
     test_has_not_nothrow_default_constructor<DThrows>(); // This is LWG2116
-#endif
 
     test_is_nothrow_default_constructible<Union>();
     test_is_nothrow_default_constructible<Empty>();
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
index ab09a34ffc1..3ee4685d9a1 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
@@ -92,7 +92,6 @@ int main(int, char**)
     test_is_nothrow_destructible<const int*>();
     test_is_nothrow_destructible<char[3]>();
 
-#if TEST_STD_VER >= 2011
     // requires noexcept. These are all destructible.
     test_is_nothrow_destructible<PublicDestructor>();
     test_is_nothrow_destructible<VirtualPublicDestructor>();
@@ -101,7 +100,6 @@ int main(int, char**)
     test_is_nothrow_destructible<Abstract>();
     test_is_nothrow_destructible<Empty>();
     test_is_nothrow_destructible<Union>();
-#endif
     // requires access control
     test_is_not_nothrow_destructible<ProtectedDestructor>();
     test_is_not_nothrow_destructible<PrivateDestructor>();
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
index a026b0d5fee..151c62a09d0 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
@@ -64,13 +64,8 @@ class Abstract
     virtual ~Abstract() = 0;
 };
 
-#if TEST_STD_VER >= 2011
 class Final final {
 };
-#else
-class Final {
-};
-#endif
 
 int main(int, char**)
 {
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
index f29350a54d4..2a6d263dbb9 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
@@ -107,7 +107,6 @@ int main(int, char**)
     test_is_trivially_destructible<char[3]>();
     test_is_trivially_destructible<bit_zero>();
 
-#if TEST_STD_VER >= 2011
     // requires access control sfinae
     test_is_not_trivially_destructible<ProtectedDestructor>();
     test_is_not_trivially_destructible<PrivateDestructor>();
@@ -115,7 +114,6 @@ int main(int, char**)
     test_is_not_trivially_destructible<VirtualPrivateDestructor>();
     test_is_not_trivially_destructible<PureProtectedDestructor>();
     test_is_not_trivially_destructible<PurePrivateDestructor>();
-#endif
 
 #if TEST_HAS_BUILTIN_IDENTIFIER(_Atomic)
     test_is_trivially_destructible<_Atomic int>();
diff --git a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
index cf4a500cbde..21b5bfdee41 100644
--- a/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
@@ -59,7 +59,6 @@ struct A
     A(const A&);
 };
 
-#if TEST_STD_VER >= 2011
 
 struct MoveOnly1
 {
@@ -71,7 +70,6 @@ struct MoveOnly2
     MoveOnly2(MoveOnly2&&) = default;
 };
 
-#endif
 
 int main(int, char**)
 {
@@ -88,10 +86,8 @@ int main(int, char**)
     test_is_trivially_move_constructible<const int*>();
     test_is_trivially_move_constructible<bit_zero>();
 
-#if TEST_STD_VER >= 2011
     static_assert(!std::is_trivially_move_constructible<MoveOnly1>::value, "");
     static_assert( std::is_trivially_move_constructible<MoveOnly2>::value, "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
index a663188fa70..e5d03a7183d 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
@@ -42,7 +42,6 @@ void test_basic() {
     static_assert((std::is_same<typename P::pointer, Deleter::pointer>::value),
                   "");
   }
-#if TEST_STD_VER >= 2011
   {
     typedef std::unique_ptr<VT, D2> P;
     static_assert(std::is_same<typename P::pointer, int*>::value, "");
@@ -51,7 +50,6 @@ void test_basic() {
     typedef std::unique_ptr<VT, D3> P;
     static_assert(std::is_same<typename P::pointer, int*>::value, "");
   }
-#endif
 }
 
 int main(int, char**) {
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
index c94cf666e69..910b89ae321 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
@@ -87,13 +87,11 @@ int main(int, char**) {
   }
   assert(A::count == 0);
   assert(B::count == 0);
-#if TEST_STD_VER >= 2011
   {
     static_assert(std::is_nothrow_constructible<std::unique_ptr<A>,
                                                 std::auto_ptr<B>&&>::value,
                   "");
   }
-#endif
   test_sfinae();
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
index aa2489960f5..4e3acc7c263 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
@@ -30,21 +30,18 @@
 #include "deleter_types.h"
 #include "unique_ptr_test_helper.h"
 
-#if defined(_LIBCUDACXX_VERSION) && TEST_STD_VER >= 2011
+#if defined(_LIBCUDACXX_VERSION)
 _LIBCUDACXX_SAFE_STATIC std::unique_ptr<int> global_static_unique_ptr_single;
 _LIBCUDACXX_SAFE_STATIC std::unique_ptr<int[]> global_static_unique_ptr_runtime;
 #endif
 
-#if TEST_STD_VER >= 2011
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
   void operator()(void*) const {}
 };
-#endif
 
 template <class ElemType>
 void test_sfinae() {
-#if TEST_STD_VER >= 2011
   { // the constructor does not participate in overload resolution when
     // the deleter is a pointer type
     using U = std::unique_ptr<ElemType, void (*)(void*)>;
@@ -60,19 +57,16 @@ void test_sfinae() {
     static_assert(!std::is_default_constructible<U2>::value, "");
     static_assert(!std::is_default_constructible<U3>::value, "");
   }
-#endif
 }
 
 template <class ElemType>
 void test_basic() {
-#if TEST_STD_VER >= 2011
   {
     using U1 = std::unique_ptr<ElemType>;
     using U2 = std::unique_ptr<ElemType, Deleter<ElemType> >;
     static_assert(std::is_nothrow_default_constructible<U1>::value, "");
     static_assert(std::is_nothrow_default_constructible<U2>::value, "");
   }
-#endif
   {
     std::unique_ptr<ElemType> p;
     assert(p.get() == 0);
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
index acea75ada63..3c0c7cafcb7 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
@@ -139,7 +139,6 @@ void test_basic() {
 
 template <class VT>
 void test_noexcept() {
-#if TEST_STD_VER >= 2011
   {
     typedef std::unique_ptr<VT> U;
     static_assert(std::is_nothrow_move_constructible<U>::value, "");
@@ -156,7 +155,6 @@ void test_noexcept() {
     typedef std::unique_ptr<VT, const NCConstDeleter<VT> &> U;
     static_assert(std::is_nothrow_move_constructible<U>::value, "");
   }
-#endif
 }
 
 int main(int, char**) {
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
index f817a210d2e..cac5a985c7c 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
@@ -19,22 +19,19 @@
 #include "unique_ptr_test_helper.h"
 
 
-#if defined(_LIBCUDACXX_VERSION) && TEST_STD_VER >= 2011
+#if defined(_LIBCUDACXX_VERSION)
 _LIBCUDACXX_SAFE_STATIC std::unique_ptr<int> global_static_unique_ptr_single(nullptr);
 _LIBCUDACXX_SAFE_STATIC std::unique_ptr<int[]> global_static_unique_ptr_runtime(nullptr);
 #endif
 
 
-#if TEST_STD_VER >= 2011
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
   void operator()(void*) const {}
 };
-#endif
 
 template <class VT>
 void test_basic() {
-#if TEST_STD_VER >= 2011
   {
     using U1 = std::unique_ptr<VT>;
     using U2 = std::unique_ptr<VT, Deleter<VT> >;
@@ -43,7 +40,6 @@ void test_basic() {
     static_assert(std::is_nothrow_constructible<U2, decltype(nullptr)>::value,
                   "");
   }
-#endif
   {
     std::unique_ptr<VT> p(nullptr);
     assert(p.get() == 0);
@@ -57,7 +53,6 @@ void test_basic() {
 
 template <class VT>
 void test_sfinae() {
-#if TEST_STD_VER >= 2011
   { // the constructor does not participate in overload resultion when
     // the deleter is a pointer type
     using U = std::unique_ptr<VT, void (*)(void*)>;
@@ -73,7 +68,6 @@ void test_sfinae() {
     static_assert(!std::is_constructible<U2, decltype(nullptr)>::value, "");
     static_assert(!std::is_constructible<U3, decltype(nullptr)>::value, "");
   }
-#endif
 }
 
 DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
index 5e44b4a1b74..ff201c0df08 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
@@ -40,7 +40,6 @@ template <bool IsArray>
 void test_pointer() {
   typedef typename std::conditional<!IsArray, A, A[]>::type ValueT;
   const int expect_alive = IsArray ? 5 : 1;
-#if TEST_STD_VER >= 2011
   {
     using U1 = std::unique_ptr<ValueT>;
     using U2 = std::unique_ptr<ValueT, Deleter<ValueT> >;
@@ -53,7 +52,6 @@ void test_pointer() {
     static_assert(!std::is_convertible<A*, U1>::value, "");
     static_assert(!std::is_convertible<A*, U2>::value, "");
   }
-#endif
   {
     A* p = newValue<ValueT>(expect_alive);
     assert(A::count == expect_alive);
@@ -93,7 +91,6 @@ void test_derived() {
   assert(B::count == 0);
 }
 
-#if TEST_STD_VER >= 2011
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
   void operator()(void*) const {}
@@ -102,11 +99,9 @@ struct NonDefaultDeleter {
 struct GenericDeleter {
   void operator()(void*) const;
 };
-#endif
 
 template <class T>
 void test_sfinae() {
-#if TEST_STD_VER >= 2011
   { // the constructor does not participate in overload resultion when
     // the deleter is a pointer type
     using U = std::unique_ptr<T, void (*)(void*)>;
@@ -122,11 +117,9 @@ void test_sfinae() {
     static_assert(!std::is_constructible<U2, T*>::value, "");
     static_assert(!std::is_constructible<U3, T*>::value, "");
   }
-#endif
 }
 
 static void test_sfinae_runtime() {
-#if TEST_STD_VER >= 2011
   { // the constructor does not participate in overload resolution when
     // a base <-> derived conversion would occur.
     using UA = std::unique_ptr<A[]>;
@@ -143,7 +136,6 @@ static void test_sfinae_runtime() {
     static_assert(!std::is_constructible<UAC, const B*>::value, "");
     static_assert(!std::is_constructible<UBC, const A*>::value, "");
   }
-#endif
 }
 
 DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
index 43cb10c1960..0765aadc9c4 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
@@ -32,7 +32,6 @@ bool my_free_called = false;
 
 void my_free(void*) { my_free_called = true; }
 
-#if TEST_STD_VER >= 2011
 struct DeleterBase {
   void operator()(void*) const {}
 };
@@ -49,11 +48,9 @@ struct NoCopyMoveDeleter : DeleterBase {
   NoCopyMoveDeleter() = default;
   NoCopyMoveDeleter(NoCopyMoveDeleter const&) = delete;
 };
-#endif
 
 template <bool IsArray>
 void test_sfinae() {
-#if TEST_STD_VER >= 2011
   typedef typename std::conditional<!IsArray, int, int[]>::type VT;
   {
     using D = CopyOnlyDeleter;
@@ -98,12 +95,10 @@ void test_sfinae() {
     static_assert(!std::is_constructible<U, int*, D&&>::value, "");
     static_assert(!std::is_constructible<U, int*, const D&&>::value, "");
   }
-#endif
 }
 
 template <bool IsArray>
 void test_noexcept() {
-#if TEST_STD_VER >= 2011
   typedef typename std::conditional<!IsArray, int, int[]>::type VT;
   {
     using D = CopyOnlyDeleter;
@@ -130,11 +125,9 @@ void test_noexcept() {
     static_assert(std::is_nothrow_constructible<U, int*, D const&>::value, "");
     static_assert(std::is_nothrow_constructible<U, int*, D&>::value, "");
   }
-#endif
 }
 
 void test_sfinae_runtime() {
-#if TEST_STD_VER >= 2011
   {
     using D = CopyOnlyDeleter;
     using U = std::unique_ptr<A[], D>;
@@ -200,7 +193,6 @@ void test_sfinae_runtime() {
     static_assert(!std::is_constructible<U, B*, D&&>::value, "");
     static_assert(!std::is_constructible<U, B*, const D&&>::value, "");
   }
-#endif
 }
 
 template <bool IsArray>
@@ -290,7 +282,6 @@ void test_basic_single() {
 
 template <bool IsArray>
 void test_nullptr() {
-#if TEST_STD_VER >= 2011
   typedef typename std::conditional<!IsArray, A, A[]>::type VT;
   {
     std::unique_ptr<VT, Deleter<VT> > u(nullptr, Deleter<VT>{});
@@ -306,7 +297,6 @@ void test_nullptr() {
     std::unique_ptr<VT, NCConstDeleter<VT> const& > u(nullptr, d);
     assert(u.get() == nullptr);
   }
-#endif
 }
 
 int main(int, char**) {
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
index 280c8bcd220..6d213beeaba 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
@@ -22,13 +22,11 @@ template <bool IsArray>
 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
-#if TEST_STD_VER >= 2011
   {
     using U = std::unique_ptr<VT>;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.release());
   }
-#endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
     assert(A::count == expect_alive);
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
index ce16bddf054..afa1bd926a3 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
@@ -22,13 +22,11 @@ template <bool IsArray>
 void test_reset_pointer() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
-#if TEST_STD_VER >= 2011
   {
     using U = std::unique_ptr<VT>;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.reset((A*)nullptr));
   }
-#endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
     assert(A::count == expect_alive);
@@ -59,13 +57,11 @@ template <bool IsArray>
 void test_reset_nullptr() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
-#if TEST_STD_VER >= 2011
   {
     using U = std::unique_ptr<VT>;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.reset(nullptr));
   }
-#endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
     assert(A::count == expect_alive);
@@ -83,13 +79,11 @@ template <bool IsArray>
 void test_reset_no_arg() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
-#if TEST_STD_VER >= 2011
   {
     using U = std::unique_ptr<VT>;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.reset());
   }
-#endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
     assert(A::count == expect_alive);
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
index 9df5535dff6..401f769f0d0 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
@@ -51,13 +51,11 @@ template <bool IsArray>
 void test_basic() {
   typedef typename std::conditional<IsArray, TT[], TT>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
-#if TEST_STD_VER >= 2011
   {
     using U = std::unique_ptr<VT, Deleter<VT> >;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.swap(u));
   }
-#endif
   {
     TT* p1 = newValueInit<VT>(expect_alive, 1);
     std::unique_ptr<VT, Deleter<VT> > s1(p1, Deleter<VT>(1));
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
index 1efaa023b85..2193f77cb30 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
@@ -39,12 +39,10 @@ void test_basic() {
     static_assert((std::is_constructible<bool, U>::value), "");
     static_assert((std::is_constructible<bool, U const&>::value), "");
   }
-#if TEST_STD_VER >= 2011
   {
     static_assert(!std::is_convertible<U, bool>::value, "");
     static_assert(!std::is_convertible<U const&, bool>::value, "");
   }
-#endif
   {
     U p(newValue<VT>(1));
     U const& cp = p;
diff --git a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
index a3c87714e9f..20ce943f240 100644
--- a/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
@@ -84,7 +84,6 @@ int main(int, char**)
     assert(A::count == 6);
     }
     assert(A::count == 0);
-#if TEST_STD_VER >= 2011
     {
         // test that unique_ptr's specialized swap is disabled when the deleter
         // is non-swappable. Instead we should pick up the generic swap(T, T)
@@ -97,7 +96,6 @@ int main(int, char**)
         std::unique_ptr<int, D&> p2(&y, d);
         std::swap(p, p2);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
index f0172a4ba74..ad2a9d9f2f3 100644
--- a/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
@@ -26,12 +26,10 @@ void test_default_ctor()
         for (std::size_t i = 0; i < N; ++i)
             assert(v1[i] == false);
     }
-#if TEST_STD_VER >= 2011
     {
         constexpr std::bitset<N> v1;
         static_assert(v1.size() == N, "");
     }
-#endif
 }
 
 
diff --git a/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp b/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
index b5dfcad566a..ed992204800 100644
--- a/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
@@ -31,12 +31,10 @@ void test_val_ctor()
         for (std::size_t i = M; i < N; ++i)
             assert(v[i] == false);
     }
-#if TEST_STD_VER >= 2011
     {
         constexpr std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
         static_assert(v.size() == N, "");
     }
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
index ef9b9bb3d2f..5073c1887fe 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
@@ -24,13 +24,11 @@ int main(int, char**)
     std::chrono::minutes m2 = +m;
     assert(m.count() == m2.count());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::minutes m(3);
     constexpr std::chrono::minutes m2 = +m;
     static_assert(m.count() == m2.count(), "");
     }
-#endif
 
 // P0548
     {
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
index 593a593e4a8..96085185e67 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
@@ -24,13 +24,11 @@ int main(int, char**)
     std::chrono::minutes m2 = -m;
     assert(m2.count() == -m.count());
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::minutes m(3);
     constexpr std::chrono::minutes m2 = -m;
     static_assert(m2.count() == -m.count(), "");
     }
-#endif
 
 // P0548
     {
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
index 03a55761b44..b11cfcab5bc 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
@@ -39,14 +39,12 @@ int main(int, char**)
     static_assert(test_constexpr(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     { // This is PR#41130
     std::chrono::nanoseconds d(5);
     NotARep n;
     d /= n;
     assert(d.count() == 5);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
index 4971fcfe1c6..6bdd06891d8 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
@@ -43,14 +43,12 @@ int main(int, char**)
     static_assert(test_constexpr(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     { // This is PR#41130
     std::chrono::nanoseconds d(5);
     NotARep n;
     d %= n;
     assert(d.count() == 5);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
index 44d5e4f7533..ba991539495 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
@@ -43,14 +43,12 @@ int main(int, char**)
     static_assert(test_constexpr(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     { // This is PR#41130
     Duration d(5);
     NotARep n;
     d %= n;
     assert(d.count() == 5);
     }
-#endif
 
 
   return 0;
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
index 26f225d34c6..22d79587363 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
@@ -39,14 +39,12 @@ int main(int, char**)
     static_assert(test_constexpr(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     { // This is PR#41130
     std::chrono::nanoseconds d(5);
     NotARep n;
     d *= n;
     assert(d.count() == 5);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
index 02d35c194c3..45df4f9a202 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
@@ -44,12 +44,10 @@ int main(int, char**)
          std::chrono::duration<double, std::ratio<3600> >(7265./3600));
     test(std::chrono::duration<int, std::ratio<2, 3> >(9),
          std::chrono::duration<int, std::ratio<3, 5> >(10));
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::hours h = std::chrono::duration_cast<std::chrono::hours>(std::chrono::milliseconds(7265000));
     static_assert(h.count() == 2, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
index 43f83efed11..8da278f51a4 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
@@ -69,7 +69,6 @@ int main(int, char**)
     assert(s1 == s2);
     assert(!(s1 != s2));
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::seconds s1(3);
     constexpr std::chrono::seconds s2(3);
@@ -112,7 +111,6 @@ int main(int, char**)
     static_assert(s1 == s2, "");
     static_assert(!(s1 != s2), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
index de6790c64c2..39c57c14882 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
@@ -93,7 +93,6 @@ int main(int, char**)
     assert( (s1 <= s2));
     assert( (s1 >= s2));
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::seconds s1(3);
     constexpr std::chrono::seconds s2(3);
@@ -150,7 +149,6 @@ int main(int, char**)
     static_assert( (s1 <= s2), "");
     static_assert( (s1 >= s2), "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
index 4daca0c000c..ae067cc8282 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
@@ -27,13 +27,11 @@ int main(int, char**)
     std::chrono::microseconds us = ms;
     assert(us.count() == 1000);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::milliseconds ms(1);
     constexpr std::chrono::microseconds us = ms;
     static_assert(us.count() == 1000, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
index 8535a045fc2..d87f6591e6e 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
@@ -27,13 +27,11 @@ int main(int, char**)
     std::chrono::duration<double, std::milli> ms = us;
     assert(ms.count() == 1./1000);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::duration<double, std::micro> us(1);
     constexpr std::chrono::duration<double, std::milli> ms = us;
     static_assert(ms.count() == 1./1000, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
index 26b9d40f3d0..b0fc2a589e6 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
@@ -27,13 +27,11 @@ int main(int, char**)
     std::chrono::duration<double, std::milli> d = i;
     assert(d.count() == 3000);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::duration<int> i(3);
     constexpr std::chrono::duration<double, std::milli> d = i;
     static_assert(d.count() == 3000, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
index 90ade222fdb..fef9173837f 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
@@ -26,10 +26,8 @@ test()
 {
     D d;
     assert(d.count() == typename D::rep());
-#if TEST_STD_VER >= 2011
     constexpr D d2 = D();
     static_assert(d2.count() == typename D::rep(), "");
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
index 5c19e9d64bd..41e51f4430f 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
@@ -25,10 +25,8 @@ test(R r)
 {
     D d(r);
     assert(d.count() == r);
-#if TEST_STD_VER >= 2011
     constexpr D d2(R(2));
     static_assert(d2.count() == 2, "");
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
index 69d2b40ebd9..1b291ecd66f 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
@@ -24,10 +24,8 @@ int main(int, char**)
 {
     std::chrono::duration<double> d(5);
     assert(d.count() == 5);
-#if TEST_STD_VER >= 2011
     constexpr std::chrono::duration<double> d2(5);
     static_assert(d2.count() == 5, "");
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
index d4b6e45ef74..61681aa57ce 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
@@ -45,7 +45,6 @@ int main(int, char**)
     std::chrono::duration<double, std::ratio<1, 15> > r = s1 + s2;
     assert(r.count() == 75);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::seconds s1(3);
     constexpr std::chrono::seconds s2(5);
@@ -70,7 +69,6 @@ int main(int, char**)
     constexpr std::chrono::duration<double, std::ratio<1, 15> > r = s1 + s2;
     static_assert(r.count() == 75, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
index 00ba8426a8a..e987bfe2cae 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
@@ -46,7 +46,6 @@ int main(int, char**)
     std::chrono::duration<double, std::ratio<1, 15> > r = s1 - s2;
     assert(r.count() == -15);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::seconds s1(3);
     constexpr std::chrono::seconds s2(5);
@@ -71,7 +70,6 @@ int main(int, char**)
     constexpr std::chrono::duration<double, std::ratio<1, 15> > r = s1 - s2;
     static_assert(r.count() == -15, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
index 8a429a21e48..530eba681e5 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
@@ -43,7 +43,6 @@ int main(int, char**)
     std::chrono::duration<double, std::ratio<3, 5> > s2(5);
     assert(s1 / s2 == truncate_fp(20./3));
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::nanoseconds ns1(15);
     constexpr std::chrono::nanoseconds ns2(5);
@@ -64,7 +63,6 @@ int main(int, char**)
     constexpr std::chrono::duration<double, std::ratio<3, 5> > s2(5);
     static_assert(s1 / s2 == 20./3, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
index a082fe561ac..7ce573d5f70 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
@@ -30,15 +30,12 @@ int main(int, char**)
     ns = ns / 5;
     assert(ns.count() == 3);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::nanoseconds ns(15);
     constexpr std::chrono::nanoseconds ns2 = ns / 5;
     static_assert(ns2.count() == 3, "");
     }
-#endif
 
-#if TEST_STD_VER >= 2011
     { // This is PR#41130
     typedef std::chrono::nanoseconds Duration;
     Duration d(5);
@@ -47,7 +44,6 @@ int main(int, char**)
     d = d / n;
     assert(d.count() == 5);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
index 7c9eaaf1040..01e9f8a3ddc 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
@@ -40,7 +40,6 @@ int main(int, char**)
     std::chrono::duration<int, std::ratio<1, 15> > r = s1 % s2;
     assert(r.count() == 24);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::nanoseconds ns1(15);
     constexpr std::chrono::nanoseconds ns2(6);
@@ -59,7 +58,6 @@ int main(int, char**)
     constexpr std::chrono::duration<int, std::ratio<1, 15> > r = s1 % s2;
     static_assert(r.count() == 24, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
index ed13321e7c6..885c4c3bd26 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
@@ -30,15 +30,12 @@ int main(int, char**)
     ns = ns % 6;
     assert(ns.count() == 3);
     }
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::nanoseconds ns(15);
     constexpr std::chrono::nanoseconds ns2 = ns % 6;
     static_assert(ns2.count() == 3, "");
     }
-#endif
 
-#if TEST_STD_VER >= 2011
     { // This is PR#41130
     typedef std::chrono::seconds Duration;
     Duration d(5);
@@ -47,7 +44,6 @@ int main(int, char**)
     d = d % n;
     assert(d.count() == 5);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
index 24ba172d3e2..c94983d3a39 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
@@ -36,7 +36,6 @@ int main(int, char**)
     assert(ns.count() == 90);
     }
 
-#if TEST_STD_VER >= 2011
     {
     constexpr std::chrono::nanoseconds ns(3);
     constexpr std::chrono::nanoseconds ns2 = ns * 5;
@@ -44,9 +43,7 @@ int main(int, char**)
     constexpr std::chrono::nanoseconds ns3 = 6 * ns;
     static_assert(ns3.count() == 18, "");
     }
-#endif
 
-#if TEST_STD_VER >= 2011
     { // This is related to PR#41130
     typedef std::chrono::nanoseconds Duration;
     Duration d(5);
@@ -58,7 +55,6 @@ int main(int, char**)
     d = n * d;
     assert(d.count() == 5);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
index 23d28938287..9fd92c00036 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
@@ -31,13 +31,11 @@ void test()
     Rep max_rep = std::chrono::duration_values<Rep>::max();
     assert(D::max().count() == max_rep);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef typename D::rep Rep;
     constexpr Rep max_rep = std::chrono::duration_values<Rep>::max();
     static_assert(D::max().count() == max_rep, "");
     }
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
index 42745958056..521772b3741 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
@@ -31,13 +31,11 @@ void test()
     Rep min_rep = std::chrono::duration_values<Rep>::min();
     assert(D::min().count() == min_rep);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef typename D::rep Rep;
     constexpr Rep min_rep = std::chrono::duration_values<Rep>::min();
     static_assert(D::min().count() == min_rep, "");
     }
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
index f543d83fbcc..b61040fb11f 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
@@ -30,13 +30,11 @@ void test()
     Rep zero_rep = std::chrono::duration_values<Rep>::zero();
     assert(D::zero().count() == zero_rep);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef typename D::rep Rep;
     constexpr Rep zero_rep = std::chrono::duration_values<Rep>::zero();
     static_assert(D::zero().count() == zero_rep, "");
     }
-#endif
 }
 
 int main(int, char**)
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
index 90c7c527c9d..a25cfa1a820 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
@@ -25,14 +25,12 @@ int main(int, char**)
            std::numeric_limits<double>::max());
     assert(std::chrono::duration_values<Rep>::max() ==
            std::numeric_limits<Rep>::max());
-#if TEST_STD_VER >= 2011
     static_assert(std::chrono::duration_values<int>::max() ==
            std::numeric_limits<int>::max(), "");
     static_assert(std::chrono::duration_values<double>::max() ==
            std::numeric_limits<double>::max(), "");
     static_assert(std::chrono::duration_values<Rep>::max() ==
            std::numeric_limits<Rep>::max(), "");
-#endif
 
     LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<int>::max());
     LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<double>::max());
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
index ec68537a04e..94298943434 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
@@ -25,14 +25,12 @@ int main(int, char**)
            std::numeric_limits<double>::lowest());
     assert(std::chrono::duration_values<Rep>::min() ==
            std::numeric_limits<Rep>::lowest());
-#if TEST_STD_VER >= 2011
     static_assert(std::chrono::duration_values<int>::min() ==
            std::numeric_limits<int>::lowest(), "");
     static_assert(std::chrono::duration_values<double>::min() ==
            std::numeric_limits<double>::lowest(), "");
     static_assert(std::chrono::duration_values<Rep>::min() ==
            std::numeric_limits<Rep>::lowest(), "");
-#endif
 
     LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<int>::min());
     LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<double>::min());
diff --git a/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp b/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
index 930daa70698..9b34109be4f 100644
--- a/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
@@ -20,10 +20,8 @@ int main(int, char**)
 {
     assert(std::chrono::duration_values<int>::zero() == 0);
     assert(std::chrono::duration_values<Rep>::zero() == 0);
-#if TEST_STD_VER >= 2011
     static_assert(std::chrono::duration_values<int>::zero() == 0, "");
     static_assert(std::chrono::duration_values<Rep>::zero() == 0, "");
-#endif
 
     LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<int>::zero());
     LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::zero());
diff --git a/libcudacxx/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp b/libcudacxx/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
index 70c0dd04823..aeab26b71fe 100644
--- a/libcudacxx/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
@@ -20,9 +20,7 @@
 #include <type_traits>
 
 #include "test_macros.h"
-#if TEST_STD_VER >= 2011
 #include "poisoned_hash_helper.h"
-#endif
 
 int main(int, char**)
 {
@@ -33,11 +31,9 @@ int main(int, char**)
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
 #endif
   }
-#if TEST_STD_VER >= 2011
   {
     test_hash_enabled_for_type<std::type_index>(std::type_index(typeid(int)));
   }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp b/libcudacxx/libcxx/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
index 93500f14b57..05fc7a228b7 100644
--- a/libcudacxx/libcxx/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
@@ -46,20 +46,11 @@ int main(int, char**)
     A a;
     const A ca;
 
-#if TEST_STD_VER >= 2011
     static_assert((std::is_same<decltype(std::move_if_noexcept(i)), int&&>::value), "");
     static_assert((std::is_same<decltype(std::move_if_noexcept(ci)), const int&&>::value), "");
     static_assert((std::is_same<decltype(std::move_if_noexcept(a)), A&&>::value), "");
     static_assert((std::is_same<decltype(std::move_if_noexcept(ca)), const A&&>::value), "");
     static_assert((std::is_same<decltype(std::move_if_noexcept(l)), const legacy&>::value), "");
-#else  // C++ < 11
-    // In C++03 we don't have noexcept so we can never move :-(
-    static_assert((std::is_same<decltype(std::move_if_noexcept(i)), const int&>::value), "");
-    static_assert((std::is_same<decltype(std::move_if_noexcept(ci)), const int&>::value), "");
-    static_assert((std::is_same<decltype(std::move_if_noexcept(a)), const A&>::value), "");
-    static_assert((std::is_same<decltype(std::move_if_noexcept(ca)), const A&>::value), "");
-    static_assert((std::is_same<decltype(std::move_if_noexcept(l)), const legacy&>::value), "");
-#endif
 
 #if TEST_STD_VER > 2011
     constexpr int i1 = 23;
diff --git a/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp b/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
index dc60a3aecaa..911d4554546 100644
--- a/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
@@ -16,9 +16,7 @@
 #include <cassert>
 
 #include "test_macros.h"
-#if TEST_STD_VER >= 2011
 #include "archetypes.h"
-#endif
 
 int main(int, char**)
 {
@@ -31,7 +29,6 @@ int main(int, char**)
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
-#if TEST_STD_VER >= 2011
     {
        using C = TestTypes::TestType;
        using P = std::pair<int, C>;
@@ -47,7 +44,6 @@ int main(int, char**)
        assert(p.first == 42);
        assert(p.second.value == -42);
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp b/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
index 712a704174d..2f98d714ae3 100644
--- a/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -31,7 +31,6 @@ int main(int, char**)
         assert(p.first == 0.0f);
         assert(p.second == nullptr);
     }
-#if TEST_STD_VER >= 2011
     {
         typedef std::pair<float, short*> P;
         constexpr P p;
@@ -50,7 +49,6 @@ int main(int, char**)
         struct Derived : Base { protected: Derived() = default; };
         static_assert(!std::is_default_constructible<std::pair<Derived, int> >::value, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp b/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
index b221254afa1..10fd0585368 100644
--- a/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
@@ -30,7 +30,6 @@ int main(int, char**)
         static_assert(std::is_copy_constructible<P>::value, "");
         static_assert(std::is_trivially_copy_constructible<P>::value, "");
     }
-#if TEST_STD_VER >= 2011
     {
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(std::is_trivially_move_constructible<P>::value, "");
@@ -42,7 +41,6 @@ int main(int, char**)
         static_assert(std::is_move_constructible<P1>::value, "");
         static_assert(std::is_trivially_move_constructible<P1>::value, "");
     }
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp b/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp
index b937ee7ee11..c9f4e641fd2 100644
--- a/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap.pass.cpp
@@ -19,7 +19,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
 struct CopyOnly {
     CopyOnly() {}
     CopyOnly(CopyOnly const&) noexcept {}
@@ -60,7 +59,6 @@ template <class Tp>
 constexpr bool can_swap() {
     return std::is_same<decltype(can_swap_test<Tp>(0)), void>::value;
 }
-#endif
 
 #if TEST_STD_VER > 2017
 constexpr bool test_swap_constexpr()
@@ -82,7 +80,6 @@ int main(int, char**)
         assert(i == 2);
         assert(j == 1);
     }
-#if TEST_STD_VER >= 2011
     {
 
         std::unique_ptr<int> i(new int(1));
@@ -108,7 +105,6 @@ int main(int, char**)
         static_assert(!noexcept(std::swap(m, m)), "");
         static_assert(noexcept(std::swap(nm, nm)), "");
     }
-#endif
 
 #if TEST_STD_VER > 2017
     static_assert(test_swap_constexpr());
diff --git a/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap_array.pass.cpp b/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
index b20b5911fc2..8007e2188ae 100644
--- a/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
+++ b/libcudacxx/libcxx/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
@@ -20,7 +20,6 @@
 #include "test_macros.h"
 
 
-#if TEST_STD_VER >= 2011
 struct CopyOnly {
     CopyOnly() {}
     CopyOnly(CopyOnly const&) noexcept {}
@@ -51,7 +50,6 @@ template <class Tp>
 constexpr bool can_swap() {
     return std::is_same<decltype(can_swap_test<Tp>(0)), void>::value;
 }
-#endif
 
 #if TEST_STD_VER > 2017
 constexpr bool test_swap_constexpr()
@@ -81,7 +79,6 @@ int main(int, char**)
         assert(j[1] == 2);
         assert(j[2] == 3);
     }
-#if TEST_STD_VER >= 2011
     {
         std::unique_ptr<int> i[3];
         for (int k = 0; k < 3; ++k)
@@ -110,7 +107,6 @@ int main(int, char**)
         static_assert(!noexcept(std::swap(ca, ca)), "");
         static_assert(noexcept(std::swap(ma, ma)), "");
     }
-#endif
 
 #if TEST_STD_VER > 2017
     static_assert(test_swap_constexpr());
diff --git a/libcudacxx/libcxx/test/support/Counter.h b/libcudacxx/libcxx/test/support/Counter.h
index 33d3c4479d5..53a2b7f53a6 100644
--- a/libcudacxx/libcxx/test/support/Counter.h
+++ b/libcudacxx/libcxx/test/support/Counter.h
@@ -23,10 +23,8 @@ class Counter : public Counter_base
     Counter(const T &data) : data_(data)            { ++gConstructed; }
     Counter(const Counter& rhs) : data_(rhs.data_)  { ++gConstructed; }
     Counter& operator=(const Counter& rhs)          { data_ = rhs.data_; return *this; }
-#if TEST_STD_VER >= 2011
     Counter(Counter&& rhs) : data_(std::move(rhs.data_))  { ++gConstructed; }
     Counter& operator=(Counter&& rhs) { ++gConstructed; data_ = std::move(rhs.data_); return *this; }
-#endif
     ~Counter() { --gConstructed; }
 
     const T& get() const {return data_;}
diff --git a/libcudacxx/libcxx/test/support/MoveOnly.h b/libcudacxx/libcxx/test/support/MoveOnly.h
index 986a340f322..ee67c4700e9 100644
--- a/libcudacxx/libcxx/test/support/MoveOnly.h
+++ b/libcudacxx/libcxx/test/support/MoveOnly.h
@@ -11,8 +11,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
-
 #include <cstddef>
 #include <functional>
 
@@ -49,6 +47,4 @@ struct hash<MoveOnly>
 
 }
 
-#endif  // TEST_STD_VER >= 2011
-
 #endif  // MOVEONLY_H
diff --git a/libcudacxx/libcxx/test/support/allocators.h b/libcudacxx/libcxx/test/support/allocators.h
index 08f0f6aee4e..4b173506d84 100644
--- a/libcudacxx/libcxx/test/support/allocators.h
+++ b/libcudacxx/libcxx/test/support/allocators.h
@@ -14,8 +14,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
-
 template <class T>
 class A1
 {
@@ -185,6 +183,4 @@ bool operator!=(const A3<T>& x, const A3<U>& y)
     return !(x == y);
 }
 
-#endif  // TEST_STD_VER >= 2011
-
 #endif  // ALLOCATORS_H
diff --git a/libcudacxx/libcxx/test/support/archetypes.h b/libcudacxx/libcxx/test/support/archetypes.h
index 6fb4d275529..c6207fec3d1 100644
--- a/libcudacxx/libcxx/test/support/archetypes.h
+++ b/libcudacxx/libcxx/test/support/archetypes.h
@@ -7,8 +7,6 @@
 #include "test_macros.h"
 #include "test_workarounds.h"
 
-#if TEST_STD_VER >= 2011
-
 namespace ArchetypeBases {
 
 template <bool, class T>
@@ -388,6 +386,4 @@ constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
 
 } // end namespace ExplicitTrivialTestTypes
 
-#endif // TEST_STD_VER >= 2011
-
 #endif // TEST_SUPPORT_ARCHETYPES_H
diff --git a/libcudacxx/libcxx/test/support/charconv_test_helpers.h b/libcudacxx/libcxx/test/support/charconv_test_helpers.h
index 97cb28189b8..03100f4c66d 100644
--- a/libcudacxx/libcxx/test/support/charconv_test_helpers.h
+++ b/libcudacxx/libcxx/test/support/charconv_test_helpers.h
@@ -17,10 +17,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER < 2011
-#error This file requires C++11
-#endif
-
 using std::false_type;
 using std::true_type;
 
diff --git a/libcudacxx/libcxx/test/support/check_assertion.h b/libcudacxx/libcxx/test/support/check_assertion.h
index 8ea123c194a..40e3ec18946 100644
--- a/libcudacxx/libcxx/test/support/check_assertion.h
+++ b/libcudacxx/libcxx/test/support/check_assertion.h
@@ -29,10 +29,6 @@
 # error "This header may only be used for libc++ tests"
 #endif
 
-#if TEST_STD_VER < 2011
-# error "C++11 or greater is required to use this header"
-#endif
-
 struct AssertionInfoMatcher {
   static const int any_line = -1;
   static constexpr const char* any_file = "*";
diff --git a/libcudacxx/libcxx/test/support/container_test_types.h b/libcudacxx/libcxx/test/support/container_test_types.h
index 42782cf71a5..a45bc30907e 100644
--- a/libcudacxx/libcxx/test/support/container_test_types.h
+++ b/libcudacxx/libcxx/test/support/container_test_types.h
@@ -89,9 +89,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER < 2011
-#error This header requires C++11 or greater
-#endif
 
 namespace detail {
 // TypeID - Represent a unique identifier for a type. TypeID allows equality
diff --git a/libcudacxx/libcxx/test/support/controlled_allocators.h b/libcudacxx/libcxx/test/support/controlled_allocators.h
index cb257df410a..0f7718bca66 100644
--- a/libcudacxx/libcxx/test/support/controlled_allocators.h
+++ b/libcudacxx/libcxx/test/support/controlled_allocators.h
@@ -19,10 +19,6 @@
 #include "test_macros.h"
 #include "type_id.h"
 
-#if TEST_STD_VER < 2011
-#error This header requires C++11 or greater
-#endif
-
 struct AllocController;
     // 'AllocController' is a concrete type that instruments and controls the
     // behavior of test allocators.
diff --git a/libcudacxx/libcxx/test/support/deleter_types.h b/libcudacxx/libcxx/test/support/deleter_types.h
index 8d07d6440ad..1a7e8f23b34 100644
--- a/libcudacxx/libcxx/test/support/deleter_types.h
+++ b/libcudacxx/libcxx/test/support/deleter_types.h
@@ -22,8 +22,6 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 2011
-
 template <class T>
 class Deleter
 {
@@ -90,68 +88,6 @@ class Deleter<T[]>
     void operator()(T* p) {delete [] p;}
 };
 
-#else // TEST_STD_VER < 2011
-
-template <class T>
-class Deleter
-{
-    mutable int state_;
-
-public:
-    Deleter() : state_(0) {}
-    explicit Deleter(int s) : state_(s) {}
-
-    Deleter(Deleter const & other) : state_(other.state_) {
-        other.state_ = 0;
-    }
-    Deleter& operator=(Deleter const& other) {
-        state_ = other.state_;
-        other.state_ = 0;
-        return *this;
-    }
-
-    ~Deleter() {assert(state_ >= 0); state_ = -1;}
-
-    template <class U>
-        Deleter(Deleter<U> d,
-            typename std::enable_if<!std::is_same<U, T>::value>::type* = 0)
-            : state_(d.state()) {}
-
-public:
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
-
-    void operator()(T* p) {delete p;}
-};
-
-template <class T>
-class Deleter<T[]>
-{
-    mutable int state_;
-
-public:
-
-    Deleter(Deleter const& other) : state_(other.state_) {
-        other.state_ = 0;
-    }
-    Deleter& operator=(Deleter const& other) {
-        state_ = other.state_;
-        other.state_ = 0;
-        return *this;
-    }
-
-    Deleter() : state_(0) {}
-    explicit Deleter(int s) : state_(s) {}
-    ~Deleter() {assert(state_ >= 0); state_ = -1;}
-
-    int state() const {return state_;}
-    void set_state(int i) {state_ = i;}
-
-    void operator()(T* p) {delete [] p;}
-};
-
-#endif
-
 template <class T>
 void
 swap(Deleter<T>& x, Deleter<T>& y)
@@ -366,12 +302,7 @@ class test_deleter
     void set_state(int i) {state_ = i;}
 
     void operator()(T* p) {assert(state_ >= 0); ++dealloc_count; delete p;}
-#if TEST_STD_VER >= 2011
     test_deleter* operator&() const = delete;
-#else
-private:
-  test_deleter* operator&() const;
-#endif
 };
 
 template <class T>
@@ -383,8 +314,6 @@ swap(test_deleter<T>& x, test_deleter<T>& y)
     y = std::move(t);
 }
 
-#if TEST_STD_VER >= 2011
-
 template <class T, size_t ID = 0>
 class PointerDeleter
 {
@@ -440,6 +369,4 @@ class PointerDeleter<T[], ID>
             typename std::enable_if<!std::is_same<U, T>::value>::type* = 0);
 };
 
-#endif // TEST_STD_VER >= 2011
-
 #endif  // SUPPORT_DELETER_TYPES_H
diff --git a/libcudacxx/libcxx/test/support/emplace_constructible.h b/libcudacxx/libcxx/test/support/emplace_constructible.h
index d53a381da55..beccbc36aac 100644
--- a/libcudacxx/libcxx/test/support/emplace_constructible.h
+++ b/libcudacxx/libcxx/test/support/emplace_constructible.h
@@ -3,7 +3,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
 template <class T>
 struct EmplaceConstructible {
   T value;
@@ -69,6 +68,5 @@ struct EmplaceConstructibleMoveableAndAssignable {
     return *this;
   }
 };
-#endif
 
 #endif // TEST_SUPPORT_EMPLACE_CONSTRUCTIBLE_H
diff --git a/libcudacxx/libcxx/test/support/min_allocator.h b/libcudacxx/libcxx/test/support/min_allocator.h
index 0ad1044614a..7bc4af05c04 100644
--- a/libcudacxx/libcxx/test/support/min_allocator.h
+++ b/libcudacxx/libcxx/test/support/min_allocator.h
@@ -47,11 +47,7 @@ class bare_allocator
 template <class T>
 class no_default_allocator
 {
-#if TEST_STD_VER >= 2011
     no_default_allocator() = delete;
-#else
-    no_default_allocator();
-#endif
     struct construct_tag {};
     explicit no_default_allocator(construct_tag) {}
 
diff --git a/libcudacxx/libcxx/test/support/nasty_containers.h b/libcudacxx/libcxx/test/support/nasty_containers.h
index 36b4e797f36..ea577f718f4 100644
--- a/libcudacxx/libcxx/test/support/nasty_containers.h
+++ b/libcudacxx/libcxx/test/support/nasty_containers.h
@@ -38,17 +38,13 @@ class nasty_vector
     explicit nasty_vector(size_type n) : v_(n) {}
     nasty_vector(size_type n, const value_type& value) : v_(n, value) {}
     template <class InputIterator> nasty_vector(InputIterator first, InputIterator last) : v_(first, last) {}
-#if TEST_STD_VER >= 2011
     nasty_vector(std::initializer_list<value_type> il) : v_(il) {}
-#endif
     ~nasty_vector() {}
 
     template <class InputIterator>
         void assign(InputIterator first, InputIterator last) { v_.assign(first, last); }
     void assign(size_type n, const value_type& u) { v_.assign(n, u); }
-#if TEST_STD_VER >= 2011
     void assign(std::initializer_list<value_type> il)  { v_.assign(il); }
-#endif
 
     iterator               begin() TEST_NOEXCEPT         { return v_.begin(); }
     const_iterator         begin()   const TEST_NOEXCEPT { return v_.begin(); }
@@ -86,30 +82,22 @@ class nasty_vector
     const value_type* data() const TEST_NOEXCEPT { return v_.data(); }
 
     void push_back(const value_type& x)     { v_.push_back(x); }
-#if TEST_STD_VER >= 2011
     void push_back(value_type&& x)          { v_.push_back(std::forward<value_type&&>(x)); }
     template <class... Args>
         void emplace_back(Args&&... args)   { v_.emplace_back(std::forward<Args>(args)...); }
-#endif
     void pop_back()                         { v_.pop_back(); }
 
-#if TEST_STD_VER >= 2011
     template <class... Args> iterator emplace(const_iterator pos, Args&&... args)
     { return v_.emplace(pos, std::forward<Args>(args)...); }
-#endif
 
     iterator insert(const_iterator pos, const value_type& x) { return v_.insert(pos, x); }
-#if TEST_STD_VER >= 2011
     iterator insert(const_iterator pos, value_type&& x)      { return v_.insert(pos, std::forward<value_type>(x)); }
-#endif
     iterator insert(const_iterator pos, size_type n, const value_type& x) { return v_.insert(pos, n, x); }
     template <class InputIterator>
         iterator insert(const_iterator pos, InputIterator first, InputIterator last)
     { return v_.insert(pos, first, last); }
 
-#if TEST_STD_VER >= 2011
     iterator insert(const_iterator pos, std::initializer_list<value_type> il) { return v_.insert(pos, il); }
-#endif
 
     iterator erase(const_iterator pos)                        { return v_.erase(pos); }
     iterator erase(const_iterator first, const_iterator last) { return v_.erase(first, last); }
@@ -161,21 +149,15 @@ class nasty_list
     nasty_list(size_type n, const value_type& value)  : l_(n,value) {}
     template <class Iter>
         nasty_list(Iter first, Iter last)  : l_(first, last) {}
-#if TEST_STD_VER >= 2011
     nasty_list(std::initializer_list<value_type> il) : l_(il) {}
-#endif
 
     ~nasty_list() {}
 
-#if TEST_STD_VER >= 2011
     nasty_list& operator=(std::initializer_list<value_type> il) { l_ = il; return *this; }
-#endif
     template <class Iter>
         void assign(Iter first, Iter last) { l_.assign(first, last); }
     void assign(size_type n, const value_type& t) { l_.assign(n, t); }
-#if TEST_STD_VER >= 2011
     void assign(std::initializer_list<value_type> il) { l_.assign(il); }
-#endif
 
 
     iterator               begin() TEST_NOEXCEPT         { return l_.begin(); }
@@ -204,34 +186,25 @@ class nasty_list
 
     void push_front(const value_type& x)    { l_.push_front(x); }
     void push_back(const value_type& x)     { l_.push_back(x); }
-#if TEST_STD_VER >= 2011
     void push_back(value_type&& x)          { l_.push_back(std::forward<value_type&&>(x)); }
     void push_front(value_type&& x)         { l_.push_back(std::forward<value_type&&>(x)); }
     template <class... Args>
         void emplace_back(Args&&... args)   { l_.emplace_back(std::forward<Args>(args)...); }
     template <class... Args>
         void emplace_front(Args&&... args)  { l_.emplace_front(std::forward<Args>(args)...); }
-#endif
     void pop_front()                        { l_.pop_front(); }
     void pop_back()                         { l_.pop_back(); }
 
-#if TEST_STD_VER >= 2011
     template <class... Args> iterator emplace(const_iterator pos, Args&&... args)
     { return l_.emplace(pos, std::forward<Args>(args)...); }
-#endif
 
     iterator insert(const_iterator pos, const value_type& x) { return l_.insert(pos, x); }
-#if TEST_STD_VER >= 2011
     iterator insert(const_iterator pos, value_type&& x)      { return l_.insert(pos, std::forward<value_type>(x)); }
-#endif
     iterator insert(const_iterator pos, size_type n, const value_type& x) { return l_.insert(pos, n, x); }
     template <class InputIterator>
         iterator insert(const_iterator pos, InputIterator first, InputIterator last)
     { return l_.insert(pos, first, last); }
-
-#if TEST_STD_VER >= 2011
     iterator insert(const_iterator pos, std::initializer_list<value_type> il) { return l_.insert(pos, il); }
-#endif
 
     iterator erase(const_iterator pos)                      { return l_.erase(pos); }
     iterator erase(const_iterator pos, const_iterator last) { return l_.erase(pos, last); }
diff --git a/libcudacxx/libcxx/test/support/poisoned_hash_helper.h b/libcudacxx/libcxx/test/support/poisoned_hash_helper.h
index 7e0e9e28b5b..08b897ad90f 100644
--- a/libcudacxx/libcxx/test/support/poisoned_hash_helper.h
+++ b/libcudacxx/libcxx/test/support/poisoned_hash_helper.h
@@ -18,10 +18,6 @@
 #include "test_macros.h"
 #include "test_workarounds.h"
 
-#if TEST_STD_VER < 2011
-#error this header may only be used in C++11 or newer
-#endif
-
 template <class ...Args> struct TypeList;
 
 // Test that the specified Hash meets the requirements of an enabled hash
diff --git a/libcudacxx/libcxx/test/support/test_allocator.h b/libcudacxx/libcxx/test/support/test_allocator.h
index ebb277fa48b..8ab472106df 100644
--- a/libcudacxx/libcxx/test/support/test_allocator.h
+++ b/libcudacxx/libcxx/test/support/test_allocator.h
@@ -96,7 +96,6 @@ class test_allocator
       assert(a.data_ != destructed_value && a.id_ != destructed_value &&
              "copying from destroyed allocator");
     }
-#if TEST_STD_VER >= 2011
     test_allocator(test_allocator&& a) TEST_NOEXCEPT : data_(a.data_),
                                                        id_(a.id_) {
       ++count;
@@ -106,7 +105,6 @@ class test_allocator
       a.data_ = moved_value;
       a.id_ = moved_value;
     }
-#endif
     template <class U>
     test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT : data_(a.data_),
                                                                id_(a.id_) {
@@ -139,13 +137,8 @@ class test_allocator
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p);}
     size_type max_size() const TEST_NOEXCEPT
         {return UINT_MAX / sizeof(T);}
-#if TEST_STD_VER < 2011
-    void construct(pointer p, const T& val)
-        {::new(static_cast<void*>(p)) T(val);}
-#else
     template <class U> void construct(pointer p, U&& val)
         {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
-#endif
     void destroy(pointer p)
         {p->~T();}
     friend bool operator==(const test_allocator& x, const test_allocator& y)
@@ -203,13 +196,8 @@ class non_default_test_allocator
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p); }
     size_type max_size() const TEST_NOEXCEPT
         {return UINT_MAX / sizeof(T);}
-#if TEST_STD_VER < 2011
-    void construct(pointer p, const T& val)
-        {::new(static_cast<void*>(p)) T(val);}
-#else
     template <class U> void construct(pointer p, U&& val)
         {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
-#endif
     void destroy(pointer p) {p->~T();}
 
     friend bool operator==(const non_default_test_allocator& x, const non_default_test_allocator& y)
@@ -284,15 +272,8 @@ class other_allocator
     typedef std::true_type propagate_on_container_move_assignment;
     typedef std::true_type propagate_on_container_swap;
 
-#if TEST_STD_VER < 2011
-    std::size_t max_size() const
-        {return UINT_MAX / sizeof(T);}
-#endif
-
 };
 
-#if TEST_STD_VER >= 2011
-
 struct Ctor_Tag {};
 
 template <typename T> class TaggingAllocator;
@@ -366,7 +347,6 @@ template<typename T, typename U>
 bool
 operator!=(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
 { return false; }
-#endif
 
 template <std::size_t MaxAllocs>
 struct limited_alloc_handle {
diff --git a/libcudacxx/libcxx/test/support/test_convertible.h b/libcudacxx/libcxx/test/support/test_convertible.h
index e0c441934c9..898af19b0be 100644
--- a/libcudacxx/libcxx/test/support/test_convertible.h
+++ b/libcudacxx/libcxx/test/support/test_convertible.h
@@ -18,10 +18,6 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER < 2011
-#error test_convertible.h requires C++11 or newer
-#endif
-
 namespace detail {
     template <class Tp> void eat_type(Tp);
 
diff --git a/libcudacxx/libcxx/test/support/test_macros.h b/libcudacxx/libcxx/test/support/test_macros.h
index ffd59f54bea..60b280e7f9f 100644
--- a/libcudacxx/libcxx/test/support/test_macros.h
+++ b/libcudacxx/libcxx/test/support/test_macros.h
@@ -149,7 +149,6 @@
 #endif
 #endif
 
-#if TEST_STD_VER >= 2011
 #define TEST_ALIGNOF(...) alignof(__VA_ARGS__)
 #define TEST_ALIGNAS(...) alignas(__VA_ARGS__)
 #define TEST_CONSTEXPR constexpr
@@ -165,41 +164,28 @@
 # define TEST_IS_CONSTANT_EVALUATED false
 #endif
 
-# if TEST_STD_VER >= 2014
-#   define TEST_CONSTEXPR_CXX14 constexpr
-# else
-#   define TEST_CONSTEXPR_CXX14
-# endif
-# if TEST_STD_VER >= 2017
-#   define TEST_CONSTEXPR_CXX17 constexpr
-# else
-#   define TEST_CONSTEXPR_CXX17
-# endif
-# if TEST_STD_VER >= 2020
-#   define TEST_CONSTEXPR_CXX20 constexpr
-# else
-#   define TEST_CONSTEXPR_CXX20
-# endif
-# if TEST_STD_VER > 2014
-#   define TEST_THROW_SPEC(...)
-# else
-#   define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
-# endif
+#if TEST_STD_VER >= 2014
+#  define TEST_CONSTEXPR_CXX14 constexpr
 #else
-#if defined(TEST_COMPILER_CLANG)
-# define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__)
+#  define TEST_CONSTEXPR_CXX14
+#endif
+#if TEST_STD_VER >= 2017
+#  define TEST_CONSTEXPR_CXX17 constexpr
 #else
-# define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
+#  define TEST_CONSTEXPR_CXX17
 #endif
-#define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
-#define TEST_CONSTEXPR
-#define TEST_CONSTEXPR_CXX14
-#define TEST_NOEXCEPT throw()
-#define TEST_NOEXCEPT_FALSE
-#define TEST_NOEXCEPT_COND(...)
-#define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
+#if TEST_STD_VER >= 2020
+#  define TEST_CONSTEXPR_CXX20 constexpr
+#else
+#  define TEST_CONSTEXPR_CXX20
+#endif
+#if TEST_STD_VER > 2014
+#  define TEST_THROW_SPEC(...)
+#else
+#  define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif
 
+
 // Sniff out to see if the underling C library has C11 features
 // Note that at this time (July 2018), MacOS X and iOS do NOT.
 // This is cribbed from __config; but lives here as well because we can't assume libc++
@@ -286,16 +272,11 @@
 #define TEST_HAS_NO_SPACESHIP_OPERATOR
 #endif
 
-#if TEST_STD_VER < 2011
-#define ASSERT_NOEXCEPT(...)
-#define ASSERT_NOT_NOEXCEPT(...)
-#else
 #define ASSERT_NOEXCEPT(...) \
     static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
 
 #define ASSERT_NOT_NOEXCEPT(...) \
     static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept")
-#endif
 
 /* Macros for testing libc++ specific behavior and extensions */
 #if defined(_LIBCUDACXX_VERSION)
diff --git a/libcudacxx/libcxx/test/support/tracked_value.h b/libcudacxx/libcxx/test/support/tracked_value.h
index 108a12ccb61..9bf4aeb39e8 100644
--- a/libcudacxx/libcxx/test/support/tracked_value.h
+++ b/libcudacxx/libcxx/test/support/tracked_value.h
@@ -23,13 +23,11 @@ struct TrackedValue {
         assert(t.state != State::DESTROYED  && "copying a destroyed object");
     }
 
-#if TEST_STD_VER >= 2011
     TrackedValue(TrackedValue&& t) : state(State::CONSTRUCTED) {
         assert(t.state != State::MOVED_FROM && "double moving from an object");
         assert(t.state != State::DESTROYED  && "moving from a destroyed object");
         t.state = State::MOVED_FROM;
     }
-#endif
 
     TrackedValue& operator=(TrackedValue const& t) {
         assert(state != State::DESTROYED && "copy assigning into destroyed object");
@@ -39,7 +37,6 @@ struct TrackedValue {
         return *this;
     }
 
-#if TEST_STD_VER >= 2011
     TrackedValue& operator=(TrackedValue&& t) {
         assert(state != State::DESTROYED && "move assigning into destroyed object");
         assert(t.state != State::MOVED_FROM && "double moving from an object");
@@ -48,7 +45,6 @@ struct TrackedValue {
         t.state = State::MOVED_FROM;
         return *this;
     }
-#endif
 
     ~TrackedValue() {
         assert(state != State::DESTROYED && "double-destroying an object");
diff --git a/libcudacxx/libcxx/test/support/type_id.h b/libcudacxx/libcxx/test/support/type_id.h
index 3e0446831f5..6d06195289b 100644
--- a/libcudacxx/libcxx/test/support/type_id.h
+++ b/libcudacxx/libcxx/test/support/type_id.h
@@ -17,10 +17,6 @@
 #include "test_macros.h"
 #include "demangle.h"
 
-#if TEST_STD_VER < 2011
-#error This header requires C++11 or greater
-#endif
-
 // TypeID - Represent a unique identifier for a type. TypeID allows equality
 // comparisons between different types.
 struct TypeID {
diff --git a/libcudacxx/libcxx/test/support/unique_ptr_test_helper.h b/libcudacxx/libcxx/test/support/unique_ptr_test_helper.h
index 0804a3f7850..b1c31ddc0fd 100644
--- a/libcudacxx/libcxx/test/support/unique_ptr_test_helper.h
+++ b/libcudacxx/libcxx/test/support/unique_ptr_test_helper.h
@@ -56,13 +56,11 @@ int getNumIncompleteTypeAlive();
 IncompleteType* getNewIncomplete();
 IncompleteType* getNewIncompleteArray(int size);
 
-#if TEST_STD_VER >= 2011
 template <class ThisT, class ...Args>
 struct args_is_this_type : std::false_type {};
 
 template <class ThisT, class A1>
 struct args_is_this_type<ThisT, A1> : std::is_same<ThisT, typename std::decay<A1>::type> {};
-#endif
 
 template <class IncompleteT = IncompleteType,
           class Del = std::default_delete<IncompleteT> >
@@ -72,7 +70,6 @@ struct StoresIncomplete {
 
   std::unique_ptr<IncompleteT, Del> m_ptr;
 
-#if TEST_STD_VER >= 2011
   StoresIncomplete(StoresIncomplete const&) = delete;
   StoresIncomplete(StoresIncomplete&&) = default;
 
@@ -80,12 +77,6 @@ struct StoresIncomplete {
   StoresIncomplete(Args&&... args) : m_ptr(std::forward<Args>(args)...) {
     static_assert(!args_is_this_type<StoresIncomplete, Args...>::value, "");
   }
-#else
-private:
-  StoresIncomplete();
-  StoresIncomplete(StoresIncomplete const&);
-public:
-#endif
 
   ~StoresIncomplete();
 
@@ -93,7 +84,6 @@ struct StoresIncomplete {
   Del& get_deleter() { return m_ptr.get_deleter(); }
 };
 
-#if TEST_STD_VER >= 2011
 template <class IncompleteT = IncompleteType,
           class Del = std::default_delete<IncompleteT>, class... Args>
 void doIncompleteTypeTest(int expect_alive, Args&&... ctor_args) {
@@ -108,7 +98,6 @@ void doIncompleteTypeTest(int expect_alive, Args&&... ctor_args) {
   }
   checkNumIncompleteTypeAlive(0);
 }
-#endif
 
 #define INCOMPLETE_TEST_EPILOGUE()                                             \
   int is_incomplete_test_anchor = is_incomplete_test();                        \
@@ -139,15 +128,9 @@ void doIncompleteTypeTest(int expect_alive, Args&&... ctor_args) {
 #pragma GCC diagnostic ignored "-Wvariadic-macros"
 #endif
 
-#if TEST_STD_VER >= 2011
 #define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                 \
   static int is_incomplete_test() { __VA_ARGS__ return 0; }                    \
   INCOMPLETE_TEST_EPILOGUE()
-#else
-#define DEFINE_AND_RUN_IS_INCOMPLETE_TEST(...)                                 \
-  static int is_incomplete_test() { return 0; }                                \
-  INCOMPLETE_TEST_EPILOGUE()
-#endif
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.cons/initialization.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.cons/initialization.pass.cpp
index ceaf4fb47fa..3ad21e959f8 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.cons/initialization.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.cons/initialization.pass.cpp
@@ -41,7 +41,6 @@ struct test_nondefault_initialization {
     __host__ __device__ TEST_CONSTEXPR_CXX14 void operator()() const
     {
         // Check direct-list-initialization syntax (introduced in C++11)
-    #if TEST_STD_VER >= 2011
         {
             {
                 cuda::std::array<T, 0> a0_0{}; unused(a0_0);
@@ -64,7 +63,6 @@ struct test_nondefault_initialization {
 
             cuda::std::array<NoDefault, 0> nodefault{}; unused(nodefault);
         }
-    #endif
 
         // Check copy-list-initialization syntax
         {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data.pass.cpp
index 889449ae720..5ca86f446e5 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data.pass.cpp
@@ -22,15 +22,6 @@ struct NoDefault {
     __host__ __device__ TEST_CONSTEXPR NoDefault(int) { }
 };
 
-#if TEST_STD_VER < 2011
-struct natural_alignment {
-    long t1;
-    long long t2;
-    double t3;
-    long double t4;
-};
-#endif
-
 __host__ __device__ TEST_CONSTEXPR_CXX14 bool tests()
 {
     {
@@ -86,11 +77,7 @@ int main(int, char**)
 
     // Test the alignment of data()
     {
-#if TEST_STD_VER < 2011
-        typedef natural_alignment T;
-#else
         typedef cuda::std::max_align_t T;
-#endif
         typedef cuda::std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data_const.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data_const.pass.cpp
index d2bab0a0d37..137421227e4 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data_const.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/array/array.data/data_const.pass.cpp
@@ -22,14 +22,6 @@ struct NoDefault {
     __host__ __device__ TEST_CONSTEXPR NoDefault(int) { }
 };
 
-#if TEST_STD_VER < 2011
-struct natural_alignment {
-    long t1;
-    long long t2;
-    double t3;
-    long double t4;
-};
-#endif
 
 __host__ __device__ TEST_CONSTEXPR_CXX14 bool tests()
 {
@@ -77,11 +69,7 @@ int main(int, char**)
 
     // Test the alignment of data()
     {
-#if TEST_STD_VER < 2011
-        typedef natural_alignment T;
-#else
         typedef cuda::std::max_align_t T;
-#endif
         typedef cuda::std::array<T, 0> C;
         const C c = {};
         const T* p = c.data();
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/array/empty.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/array/empty.pass.cpp
index 968d1fda0ce..5d18b75c3cd 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/array/empty.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/array/empty.pass.cpp
@@ -43,13 +43,11 @@ int main(int, char**)
     static_assert(tests(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     // Sanity check for constexpr in C++11
     {
         constexpr cuda::std::array<int, 3> array = {};
         static_assert(!array.empty(), "");
     }
-#endif
 
     return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/array/max_size.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/array/max_size.pass.cpp
index 0bf15c5d727..c560bb245fb 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/array/max_size.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/array/max_size.pass.cpp
@@ -43,13 +43,11 @@ int main(int, char**)
     static_assert(tests(), "");
 #endif
 
-#if TEST_STD_VER >= 2011
     // Sanity check for constexpr in C++11
     {
         constexpr cuda::std::array<int, 3> array = {};
         static_assert(array.max_size() == 3, "");
     }
-#endif
 
     return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/array/size_and_alignment.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/array/size_and_alignment.pass.cpp
index a368c778f1d..2bfc667f191 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/array/size_and_alignment.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/array/size_and_alignment.pass.cpp
@@ -54,7 +54,6 @@ __host__ __device__ void test_type() {
   test<T, 0>();
 }
 
-#if TEST_STD_VER >= 2011
 struct alignas(alignof(cuda::std::max_align_t) * 2) TestType1 {
 
 };
@@ -66,7 +65,6 @@ struct alignas(alignof(cuda::std::max_align_t) * 2) TestType2 {
 struct alignas(alignof(cuda::std::max_align_t)) TestType3 {
   char data[1000];
 };
-#endif
 
 int main(int, char**) {
   test_type<char>();
@@ -74,12 +72,10 @@ int main(int, char**) {
   test_type<double>();
   test_type<long double>();
 
-#if TEST_STD_VER >= 2011
   test_type<cuda::std::max_align_t>();
   test_type<TestType1>();
   test_type<TestType2>();
   test_type<TestType3>();
-#endif
 
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp b/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
index 609012e5902..0bc18792c30 100644
--- a/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
@@ -57,14 +57,12 @@ int main(int, char**) {
     test(&a, A());
   }
 #if defined(_LIBCUDACXX_HAS_MEMORY)
-#if TEST_STD_VER >= 2011
   {
     int i;
     cuda::std::unique_ptr<int, do_nothing> p(&i);
     test(&p, cuda::std::unique_ptr<int, do_nothing>(&i));
   }
 #endif
-#endif
 #if TEST_STD_VER > 2011
   {
     constexpr const char *p = "123456789";
diff --git a/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp b/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
index ad90953df65..527fa649ea1 100644
--- a/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -116,7 +116,6 @@ int main(int, char**) {
   test<random_access_iterator<char*> >();
   test<char*>();
 
-#if TEST_STD_VER >= 2011
   {
       typedef DummyIt<int, int> T;
       typedef cuda::std::move_iterator<T> It;
@@ -145,7 +144,6 @@ int main(int, char**) {
       typedef cuda::std::move_iterator<T> It;
       static_assert(cuda::std::is_same<It::reference, int&&>::value, "");
   }
-#endif
 
 #if TEST_STD_VER > 2014
   test<contiguous_iterator<char*>>();
diff --git a/libcudacxx/test/support/nasty_containers.h b/libcudacxx/test/support/nasty_containers.h
index 717e187c8e5..f379b7d778f 100644
--- a/libcudacxx/test/support/nasty_containers.h
+++ b/libcudacxx/test/support/nasty_containers.h
@@ -85,10 +85,8 @@ class nasty_vector
     void push_back(value_type&& x)          { v_.push_back(std::forward<value_type&&>(x)); }
     template <class... Args>
     void emplace_back(Args&&... args)   { v_.emplace_back(std::forward<Args>(args)...); }
-#endif
     void pop_back()                         { v_.pop_back(); }
 
-#if TEST_STD_VER >= 2011
     template <class... Args>
     iterator emplace(const_iterator pos, Args&&... args)
     { return v_.emplace(pos, std::forward<Args>(args)...); }
@@ -152,7 +150,6 @@ class nasty_list
     nasty_list(size_type n, const value_type& value)  : l_(n,value) {}
     template <class Iter>
     nasty_list(Iter first, Iter last)  : l_(first, last) {}
-#if TEST_STD_VER >= 2011
     nasty_list(std::initializer_list<value_type> il) : l_(il) {}
 
     ~nasty_list() {}
@@ -162,7 +159,6 @@ class nasty_list
     void assign(Iter first, Iter last) { l_.assign(first, last); }
     void assign(size_type n, const value_type& t) { l_.assign(n, t); }
     void assign(std::initializer_list<value_type> il) { l_.assign(il); }
-#endif
 
     iterator               begin() TEST_NOEXCEPT         { return l_.begin(); }
     const_iterator         begin()   const TEST_NOEXCEPT { return l_.begin(); }
@@ -196,11 +192,9 @@ class nasty_list
     void emplace_back(Args&&... args)   { l_.emplace_back(std::forward<Args>(args)...); }
     template <class... Args>
     void emplace_front(Args&&... args)  { l_.emplace_front(std::forward<Args>(args)...); }
-#endif
     void pop_front()                        { l_.pop_front(); }
     void pop_back()                         { l_.pop_back(); }
 
-#if TEST_STD_VER >= 2011
     template <class... Args>
     iterator emplace(const_iterator pos, Args&&... args)
     { return l_.emplace(pos, std::forward<Args>(args)...); }
diff --git a/libcudacxx/test/support/type_algorithms.h b/libcudacxx/test/support/type_algorithms.h
index ea6bb0257e9..d1f29b52a39 100644
--- a/libcudacxx/test/support/type_algorithms.h
+++ b/libcudacxx/test/support/type_algorithms.h
@@ -92,11 +92,9 @@ using character_types =
               ,
               char8_t
 #endif
-#if TEST_STD_VER >= 2011
               ,
               char16_t,
               char32_t
-#endif
               >;
 
 using signed_integer_types =
diff --git a/libcudacxx/test/support/type_id.h b/libcudacxx/test/support/type_id.h
index 4a855e5dbc7..f1199bed970 100644
--- a/libcudacxx/test/support/type_id.h
+++ b/libcudacxx/test/support/type_id.h
@@ -20,10 +20,6 @@
 #include "demangle.h"
 #endif // TEST_COMPILER_NVRTC
 
-#if TEST_STD_VER < 2011
-#error This header requires C++11 or greater
-#endif
-
 // TypeID - Represent a unique identifier for a type. TypeID allows equality
 // comparisons between different types.
 struct TypeID {