more files updated

changkhothuychung · changkhothuychung · commit 28f98a858b1e · 2025-03-01T15:17:17.000-05:00
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
@@ -20,23 +20,31 @@
 #include "min_allocator.h"
 
 template <class T, class Allocator>
-void test(const Allocator& a) {
+void test_util(const Allocator& a) {
   std::deque<T, Allocator> d(a);
   assert(d.size() == 0);
   assert(d.get_allocator() == a);
   LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
 }
 
-int main(int, char**) {
-  test<int>(std::allocator<int>());
-  test<NotConstructible>(test_allocator<NotConstructible>(3));
+TEST_CONSTEXPR_CXX26 bool test() {
+  test_util<int>(std::allocator<int>());
+  test_util<NotConstructible>(test_allocator<NotConstructible>(3));
 #if TEST_STD_VER >= 11
-  test<int>(min_allocator<int>());
-  test<int>(safe_allocator<int>());
-  test<NotConstructible>(min_allocator<NotConstructible>{});
-  test<NotConstructible>(safe_allocator<NotConstructible>{});
-  test<int>(explicit_allocator<int>());
-  test<NotConstructible>(explicit_allocator<NotConstructible>{});
+  test_util<int>(min_allocator<int>());
+  test_util<int>(safe_allocator<int>());
+  test_util<NotConstructible>(min_allocator<NotConstructible>{});
+  test_util<NotConstructible>(safe_allocator<NotConstructible>{});
+  test_util<int>(explicit_allocator<int>());
+  test_util<NotConstructible>(explicit_allocator<NotConstructible>{});
+#endif
+  return false;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   {
     std::deque<int> d;
     d.assign({3, 4, 5, 6});
@@ -40,6 +40,13 @@ int main(int, char**) {
     assert(d[3] == 6);
     LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
   }
+  return true;
+}
 
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -144,6 +144,8 @@ void test_iterators() {
 
 int main(int, char**) {
   basic_test();
-
+#if TEST_STD_VER >= 26
+  static_assert(basic_test());
+#endif
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
@@ -55,7 +55,7 @@ void testN(int start, int N, int M) {
   test(c1, M, -10);
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   {
     int rng[]   = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng) / sizeof(rng[0]);
@@ -74,6 +74,14 @@ int main(int, char**) {
           testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
   }
 #endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
@@ -26,7 +26,7 @@ void test(const C& x) {
   LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(x));
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool tests() {
   {
     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]);
@@ -63,6 +63,14 @@ int main(int, char**) {
     LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v2));
   }
 #endif
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+#if TEST_STD_VER >= 26
+  static_assert(tests());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
@@ -26,7 +26,7 @@ void test(const C& x, const typename C::allocator_type& a) {
   LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool tests() {
   {
     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]);
@@ -49,6 +49,14 @@ int main(int, char**) {
     test(std::deque<int, safe_allocator<int> >(ab, an, safe_allocator<int>()), safe_allocator<int>());
   }
 #endif
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+#if TEST_STD_VER >= 26
+  static_assert(tests());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
@@ -32,7 +32,7 @@
 
 struct A {};
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   //  Test the explicit deduction guides
   {
     const int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
@@ -156,6 +156,14 @@ int main(int, char**) {
 #endif
 
   SequenceContainerDeductionGuidesSfinaeAway<std::deque, std::deque<int>>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
@@ -31,13 +31,21 @@ void test() {
 #endif
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool tests() {
   test<int, std::allocator<int> >();
   test<NotConstructible, limited_allocator<NotConstructible, 1> >();
 #if TEST_STD_VER >= 11
   test<int, min_allocator<int> >();
   test<NotConstructible, min_allocator<NotConstructible> >();
 #endif
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc {
   void allocate(std::size_t);
 };
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
 #if defined(_LIBCPP_VERSION)
   {
     typedef std::deque<MoveOnly> C;
@@ -48,6 +48,14 @@ int main(int, char**) {
     typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
     static_assert(!std::is_nothrow_default_constructible<C>::value, "");
   }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_alloc {
   void allocate(std::size_t);
 };
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   {
     typedef std::deque<MoveOnly> C;
     static_assert(std::is_nothrow_destructible<C>::value, "");
@@ -46,6 +46,14 @@ int main(int, char**) {
     static_assert(!std::is_nothrow_destructible<C>::value, "");
   }
 #endif // _LIBCPP_VERSION
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/from_range.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/from_range.pass.cpp
@@ -17,7 +17,7 @@
 // template<container-compatible-range<T> R>
 //   deque(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
     test_sequence_container<std::deque, int, Iter, Sent, Alloc>([]([[maybe_unused]] const auto& c) {
       LIBCPP_ASSERT(c.__invariants());
@@ -31,6 +31,14 @@ int main(int, char**) {
   // See https://github.com/llvm/llvm-project/issues/62056.
   //test_exception_safety_throwing_copy<std::deque>();
   //test_exception_safety_throwing_allocator<std::deque, int>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   {
     std::deque<int> d = {3, 4, 5, 6};
     assert(d.size() == 4);
@@ -38,6 +38,14 @@ int main(int, char**) {
     assert(d[3] == 6);
     LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
   }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   {
     std::deque<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
     assert(d.get_allocator() == test_allocator<int>(3));
@@ -41,6 +41,14 @@ int main(int, char**) {
     assert(d[3] == 6);
     LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
   }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -105,6 +105,9 @@ void test_emplacable_concept() {
 int main(int, char**) {
   basic_test();
   test_emplacable_concept();
-
+#if TEST_STD_VER >= 26
+  static_assert(basic_test());
+  static_assert(test_emplacable_concept());
+#endif
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -101,6 +101,10 @@ void test_emplacable_concept() {
 int main(int, char**) {
   basic_test();
   test_emplacable_concept();
+#if TEST_STD_VER >= 26
+  static_assert(basic_test());
+  static_assert(test_emplacable_concept());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26 bool test() {
   {
     int ab[]      = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     const int* an = ab + sizeof(ab) / sizeof(ab[0]);
@@ -94,6 +94,14 @@ int main(int, char**) {
     LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
   }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,8 @@ void test_iterators() {`
`144`	`144`
`145`	`145`	`int main(int, char**) {`
`146`	`146`	`basic_test();`
`147`		`-`
	`147`	`+#if TEST_STD_VER >= 26`
	`148`	`+ static_assert(basic_test());`
	`149`	`+#endif`
`148`	`150`	`return 0;`
`149`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ void testN(int start, int N, int M) {`
`55`	`55`	`test(c1, M, -10);`
`56`	`56`	`}`
`57`	`57`
`58`		`-int main(int, char**) {`
	`58`	`+TEST_CONSTEXPR_CXX26 bool test() {`
`59`	`59`	`{`
`60`	`60`	`int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};`
`61`	`61`	`const int N = sizeof(rng) / sizeof(rng[0]);`
`@@ -74,6 +74,14 @@ int main(int, char**) {`
`74`	`74`	`testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);`
`75`	`75`	`}`
`76`	`76`	`#endif`
	`77`	`+ return true;`
	`78`	`+}`
	`79`	`+`
	`80`	`+int main(int, char**) {`
	`81`	`+ test();`
	`82`	`+#if TEST_STD_VER >= 26`
	`83`	`+ static_assert(test());`
	`84`	`+#endif`
`77`	`85`
`78`	`86`	`return 0;`
`79`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ void test(const C& x) {`
`26`	`26`	`LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(x));`
`27`	`27`	`}`
`28`	`28`
`29`		`-int main(int, char**) {`
	`29`	`+TEST_CONSTEXPR_CXX26 bool tests() {`
`30`	`30`	`{`
`31`	`31`	`int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};`
`32`	`32`	`int* an = ab + sizeof(ab) / sizeof(ab[0]);`
`@@ -63,6 +63,14 @@ int main(int, char**) {`
`63`	`63`	`LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v2));`
`64`	`64`	`}`
`65`	`65`	`#endif`
	`66`	`+ return true;`
	`67`	`+}`
	`68`	`+`
	`69`	`+int main(int, char**) {`
	`70`	`+ tests();`
	`71`	`+#if TEST_STD_VER >= 26`
	`72`	`+ static_assert(tests());`
	`73`	`+#endif`
`66`	`74`
`67`	`75`	`return 0;`
`68`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ void test(const C& x, const typename C::allocator_type& a) {`
`26`	`26`	`LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));`
`27`	`27`	`}`
`28`	`28`
`29`		`-int main(int, char**) {`
	`29`	`+TEST_CONSTEXPR_CXX26 bool tests() {`
`30`	`30`	`{`
`31`	`31`	`int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};`
`32`	`32`	`int* an = ab + sizeof(ab) / sizeof(ab[0]);`
`@@ -49,6 +49,14 @@ int main(int, char**) {`
`49`	`49`	`test(std::deque<int, safe_allocator<int> >(ab, an, safe_allocator<int>()), safe_allocator<int>());`
`50`	`50`	`}`
`51`	`51`	`#endif`
	`52`	`+ return true;`
	`53`	`+}`
	`54`	`+`
	`55`	`+int main(int, char**) {`
	`56`	`+ tests();`
	`57`	`+#if TEST_STD_VER >= 26`
	`58`	`+ static_assert(tests());`
	`59`	`+#endif`
`52`	`60`
`53`	`61`	`return 0;`
`54`	`62`	`}`