[libc++] Prepare string.{access, capacity, cons} tests for constexpr

Reviewed By: ldionne, #libc

Spies: libcxx-commits, arphaman

Differential Revision: https://reviews.llvm.org/D119123

libcxx/test/std/strings/basic.string/string.access/at.pass.cpp

@@ -20,7 +20,7 @@
 #include "test_macros.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos)
 {
     const S& cs = s;
@@ -54,25 +54,34 @@ test(S s, typename S::size_type pos)
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), 0);
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
     test(S("123"), 3);
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0);
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
     test(S("123"), 3);
-    }
+  }
+#endif
+
+    return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.access/back.pass.cpp

@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     const S& cs = s;
@@ -32,20 +32,29 @@ test(S s)
     assert(s.back() == typename S::value_type('z'));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
 #endif
 
-    return 0;
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
+  return 0;
 }

libcxx/test/std/strings/basic.string/string.access/front.pass.cpp

@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     const S& cs = s;
@@ -32,20 +32,29 @@ test(S s)
     assert(s.front() == typename S::value_type('z'));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
 #endif
 
-    return 0;
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
+  return 0;
 }

libcxx/test/std/strings/basic.string/string.access/index.pass.cpp

@@ -17,9 +17,8 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     S s("0123456789");
     const S& cs = s;
@@ -35,9 +34,9 @@ int main(int, char**)
     assert(cs[cs.size()] == '\0');
     const S s2 = S();
     assert(s2[0] == '\0');
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s("0123456789");
     const S& cs = s;
@@ -53,8 +52,18 @@ int main(int, char**)
     assert(cs[cs.size()] == '\0');
     const S s2 = S();
     assert(s2[0] == '\0');
-    }
+  }
 #endif
 
-    return 0;
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
+  return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp

@@ -21,7 +21,7 @@
 test_allocator_statistics alloc_stats;
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     alloc_stats.throw_after = 0;
@@ -42,9 +42,8 @@ test(S s)
     alloc_stats.throw_after = INT_MAX;
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
     S s((test_allocator<char>(&alloc_stats)));
     test(s);
@@ -54,13 +53,23 @@ int main(int, char**)
     s.assign(100, 'a');
     s.erase(50);
     test(s);
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     assert(s.capacity() > 0);
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp

@@ -17,16 +17,15 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     s.clear();
     assert(s.size() == 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     S s;
     test(s);
@@ -38,9 +37,9 @@ int main(int, char**)
     s.assign(100, 'a');
     s.erase(50);
     test(s);
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     test(s);
@@ -52,7 +51,17 @@ int main(int, char**)
     s.assign(100, 'a');
     s.erase(50);
     test(s);
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp

@@ -17,28 +17,37 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     ASSERT_NOEXCEPT(s.empty());
     assert(s.empty() == (s.size() == 0));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/empty.verify.cpp

@@ -18,10 +18,19 @@
 
 #include "test_macros.h"
 
+bool test() {
+  std::string c;
+  c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return true;
+}
+
 int main(int, char**)
 {
-    std::string c;
-    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
-    return 0;
+  return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp

@@ -23,21 +23,30 @@ test(const S& s)
     assert(s.length() == s.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp

@@ -55,21 +55,30 @@ test(const S& s)
     test2(s);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp

@@ -32,21 +32,30 @@ test(const S& s)
     assert ( false );
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp

@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(typename S::size_type min_cap, typename S::size_type erased_index)
 {
     S s(min_cap, 'a');
@@ -37,8 +37,7 @@ test(typename S::size_type min_cap, typename S::size_type erased_index)
     assert(s.capacity() >= s.size());
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef std::string S;
     {
@@ -58,5 +57,15 @@ int main(int, char**)
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp

@@ -63,41 +63,50 @@ test(typename S::size_type min_cap, typename S::size_type erased_index, typename
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     {
-    test<S>(0, 0, 5);
-    test<S>(0, 0, 10);
-    test<S>(0, 0, 50);
+      test<S>(0, 0, 5);
+      test<S>(0, 0, 10);
+      test<S>(0, 0, 50);
     }
     {
-    test<S>(100, 50, 5);
-    test<S>(100, 50, 10);
-    test<S>(100, 50, 50);
-    test<S>(100, 50, 100);
-    test<S>(100, 50, 1000);
-    test<S>(100, 50, S::npos);
-    }
+      test<S>(100, 50, 5);
+      test<S>(100, 50, 10);
+      test<S>(100, 50, 50);
+      test<S>(100, 50, 100);
+      test<S>(100, 50, 1000);
+      test<S>(100, 50, S::npos);
     }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     {
-    test<S>(0, 0, 5);
-    test<S>(0, 0, 10);
-    test<S>(0, 0, 50);
+      test<S>(0, 0, 5);
+      test<S>(0, 0, 10);
+      test<S>(0, 0, 50);
     }
     {
-    test<S>(100, 50, 5);
-    test<S>(100, 50, 10);
-    test<S>(100, 50, 50);
-    test<S>(100, 50, 100);
-    test<S>(100, 50, 1000);
-    test<S>(100, 50, S::npos);
-    }
+      test<S>(100, 50, 5);
+      test<S>(100, 50, 10);
+      test<S>(100, 50, 50);
+      test<S>(100, 50, 100);
+      test<S>(100, 50, 1000);
+      test<S>(100, 50, S::npos);
     }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp

@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, S expected)
 {
     if (n <= s.max_size())
@@ -43,9 +43,8 @@ test(S s, typename S::size_type n, S expected)
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), 0, S());
     test(S(), 1, S(1, '\0'));
@@ -63,9 +62,9 @@ int main(int, char**)
     test(S("12345678901234567890123456789012345678901234567890"), 60,
          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 >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, S());
     test(S(), 1, S(1, '\0'));
@@ -83,7 +82,17 @@ int main(int, char**)
     test(S("12345678901234567890123456789012345678901234567890"), 60,
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
     test(S(), S::npos, S("not going to happen"));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp

@@ -43,9 +43,8 @@ test(S s, typename S::size_type n, typename S::value_type c, S expected)
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S("a"));
@@ -63,9 +62,9 @@ int main(int, char**)
     test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
     test(S(), S::npos, 'a', S("not going to happen"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S("a"));
@@ -83,7 +82,17 @@ int main(int, char**)
     test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
     test(S(), S::npos, 'a', S("not going to happen"));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp

@@ -29,8 +29,7 @@ test(S s)
     assert(s.capacity() >= s.size());
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef std::string S;
     S s;
@@ -60,5 +59,15 @@ int main(int, char**)
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp

@@ -17,27 +17,36 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type c)
 {
     assert(s.size() == c);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), 0);
     test(S("123"), 3);
     test(S("12345678901234567890123456789012345678901234567890"), 50);
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp

@@ -25,7 +25,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV sv, std::size_t pos, std::size_t n)
 {
     typedef typename S::traits_type T;
@@ -59,7 +59,7 @@ test(SV sv, std::size_t pos, std::size_t n)
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a)
 {
     typedef typename S::traits_type T;
@@ -91,10 +91,8 @@ test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a)
 #endif
 }
 
-int main(int, char**)
-{
-
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
     typedef std::basic_string     <char, std::char_traits<char>, A> S;
@@ -122,10 +120,10 @@ int main(int, char**)
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   1, A(8));
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,  10, A(8));
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A(8));
-    }
+  }
 
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
     typedef std::basic_string     <char, std::char_traits<char>, A> S;
@@ -153,9 +151,9 @@ int main(int, char**)
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1, A());
     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;
     S s = "ABCD";
@@ -182,7 +180,17 @@ int main(int, char**)
 
     S s7(s.data(), 2);     // calls ctor(const char *, len)
     assert(s7 == "AB");
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp

@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test()
 {
     {
@@ -52,7 +52,7 @@ test()
 #if TEST_STD_VER >= 11
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test2()
 {
     {
@@ -85,12 +85,21 @@ test2()
 
 #endif
 
+bool test() {
+  test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
+#if TEST_STD_VER >= 11
+  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 true;
+}
+
 int main(int, char**)
 {
-    test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
-#if TEST_STD_VER >= 11
-    test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
-    test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp

@@ -18,8 +18,7 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
+bool test() {
   // Test that assignment from {} and {ptr, len} are allowed and are not
   // ambiguous.
   {
@@ -33,5 +32,15 @@ int main(int, char**)
     assert(s == "ab");
   }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp

@@ -28,23 +28,32 @@ test(S s1, typename S::value_type s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), 'a');
     test(S("1"), 'a');
     test(S("123456789"), 'a');
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a');
     test(S("1"), 'a');
     test(S("123456789"), 'a');
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp

@@ -28,23 +28,32 @@ test(S s1)
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A{}));
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

@@ -88,26 +88,25 @@ test(S s1, const typename S::allocator_type& a)
     assert(s2.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A(3));
     test(S("1"), A(5));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-    }
+  }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    {
+  {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     const char * p1 = "This is my first string";
@@ -125,9 +124,19 @@ int main(int, char**)
     test_assign(s1, s2);
     assert(s1 == p1);
     assert(s2 == p2);
-    }
+  }
 #endif
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp

@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, const S& s2)
 {
     s1 = s2;
@@ -27,9 +27,8 @@ test(S s1, const S& s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), S());
     test(S("1"), S());
@@ -46,9 +45,9 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
     test(S("1"), S());
@@ -65,16 +64,26 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
+  {   // LWG 2946
     std::string s;
     s = {"abc", 1};
     assert(s.size() == 1);
     assert(s == "a");
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

@@ -45,8 +45,8 @@ using BStr = std::basic_string<T, std::char_traits<T>, Alloc>;
 // (13) basic_string(initializer_list<CharT>, A const& = A())
 // (14) basic_string(BSV, A const& = A())
 // (15) basic_string(const T&, size_type, size_type, A const& = A())
-int main(int, char**)
-{
+bool test() {
+
   using TestSizeT = test_allocator<char>::size_type;
   { // Testing (1)
     // Nothing to do. Cannot deduce without any arguments.
@@ -365,5 +365,15 @@ int main(int, char**)
 #endif
   }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp

@@ -19,31 +19,40 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+bool test() {
+  {
+    std::string s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    std::wstring s;
+    s = {L'a', L'b', L'c'};
+    assert(s == L"abc");
+  }
+#endif
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    S s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
+    S s;
+    s = {L'a', L'b', L'c'};
+    assert(s == L"abc");
+  }
+#endif
+
+  return true;
+}
+
 int main(int, char**)
 {
-    {
-        std::string s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wstring s;
-        s = {L'a', L'b', L'c'};
-        assert(s == L"abc");
-    }
-#endif
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        S s;
-        s = {L'a', L'b', L'c'};
-        assert(s == L"abc");
-    }
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp

@@ -18,19 +18,28 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
+bool test() {
+  {
+    std::string s;
+    s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    S s;
+    s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
+
+  return true;
+}
+
 int main(int, char**)
 {
-    {
-        std::string s;
-        s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s;
-        s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 
 template <class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(It first, It last)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
@@ -41,7 +41,7 @@ test(It first, It last)
 }
 
 template <class It, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(It first, It last, const A& a)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
@@ -56,9 +56,8 @@ test(It first, It last, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
 
@@ -85,9 +84,9 @@ int main(int, char**)
 
     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 >= 11
-    {
+  {
     typedef min_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
 
@@ -114,9 +113,9 @@ int main(int, char**)
 
     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),
                     "");
@@ -124,7 +123,17 @@ int main(int, char**)
           (!std::is_constructible<std::string, std::string, std::string,
                                   std::allocator<char> >::value),
           "");
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

@@ -34,9 +34,8 @@
 #include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     const char* s = "12345678901234";
     std::basic_string s1(s, s+10);  // Can't use {} here
     using S = decltype(s1); // what type did we get?
@@ -45,9 +44,8 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-
-    {
+  }
+  {
     const char* s = "12345678901234";
     std::basic_string s1{s, s+10, std::allocator<char>{}};
     using S = decltype(s1); // what type did we get?
@@ -56,8 +54,8 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-    {
+  }
+  {
     const wchar_t* s = L"12345678901234";
     std::basic_string s1{s, s+10, test_allocator<wchar_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -66,8 +64,8 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-    {
+  }
+  {
     const char16_t* s = u"12345678901234";
     std::basic_string s1{s, s+10, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -76,8 +74,8 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-    {
+  }
+  {
     const char32_t* s = U"12345678901234";
     std::basic_string s1{s, s+10, explicit_allocator<char32_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -86,7 +84,13 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp

@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s0)
 {
     S s1 = s0;
@@ -32,22 +32,31 @@ test(S s0)
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-    }
-    {
+  }
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A{}));
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp

@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s0, const typename S::allocator_type& a)
 {
     S s1 = s0;
@@ -32,10 +32,9 @@ test(S s0, const typename S::allocator_type& a)
     assert(s2.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    test_allocator_statistics alloc_stats;
-    {
+bool test() {
+  test_allocator_statistics alloc_stats;
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
@@ -46,10 +45,10 @@ int main(int, char**)
     test(S(), A(3, &alloc_stats));
     test(S("1"), A(5, &alloc_stats));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7, &alloc_stats));
-    }
+  }
 
     int alloc_count = alloc_stats.alloc_count;
-    {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
@@ -59,9 +58,9 @@ int main(int, char**)
 #endif
     S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe", A(&alloc_stats));
     S s2 (std::move(s1), A(1, &alloc_stats));
-    }
+  }
     assert ( alloc_stats.alloc_count == alloc_count );
-    {
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
@@ -72,7 +71,17 @@ int main(int, char**)
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp

@@ -62,36 +62,45 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
+bool test() {
+  {
+    typedef std::string C;
+    static_assert(std::is_nothrow_move_assignable<C>::value, "");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
+    static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
+#if TEST_STD_VER > 14
+    // if the allocators are always equal, then the move assignment can be noexcept
+    static_assert( std::is_nothrow_move_assignable<C>::value, "");
+#else
+      static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+#endif
+  }
+#if TEST_STD_VER > 14
+  {
+    //  POCMA is false, always equal
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
+    static_assert( std::is_nothrow_move_assignable<C>::value, "");
+  }
+  {
+    //  POCMA is false, not always equal
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char>> C;
+    static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+  }
+#endif
+
+  return true;
+}
+
 int main(int, char**)
 {
-    {
-        typedef std::string C;
-        static_assert(std::is_nothrow_move_assignable<C>::value, "");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
-        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
-#if TEST_STD_VER > 14
-    //  if the allocators are always equal, then the move assignment can be noexcept
-        static_assert( std::is_nothrow_move_assignable<C>::value, "");
-#else
-        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
-#endif
-    }
-#if TEST_STD_VER > 14
-    {
-    //  POCMA is false, always equal
-        typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
-        static_assert( std::is_nothrow_move_assignable<C>::value, "");
-    }
-    {
-    //  POCMA is false, not always equal
-        typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char>> C;
-        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
-    }
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp

@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s0 = s2;
@@ -32,9 +32,8 @@ test(S s1, S s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), S());
     test(S("1"), S());
@@ -51,8 +50,8 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
-    {
+  }
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
     test(S("1"), S());
@@ -69,7 +68,17 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp

@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class charT>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
@@ -37,7 +37,7 @@ test(const charT* s)
 }
 
 template <class charT, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
@@ -51,8 +51,7 @@ test(const charT* s, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef test_allocator<char> A;
 
@@ -86,5 +85,15 @@ int main(int, char**)
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp

@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, const typename S::value_type* s2)
 {
     typedef typename S::traits_type T;
@@ -29,9 +29,8 @@ test(S s1, const typename S::value_type* s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), "");
     test(S("1"), "");
@@ -48,9 +47,9 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "");
     test(S("1"), "");
@@ -67,7 +66,17 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp

@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 template <class charT>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s, unsigned n)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
@@ -35,7 +35,7 @@ test(const charT* s, unsigned n)
 }
 
 template <class charT, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s, unsigned n, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
@@ -48,9 +48,8 @@ test(const charT* s, unsigned n, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
 
     test("", 0);
@@ -64,9 +63,9 @@ int main(int, char**)
 
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A(2));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef min_allocator<char> A;
 
     test("", 0);
@@ -80,15 +79,25 @@ int main(int, char**)
 
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A());
-    }
+  }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
+  {   // LWG 2946
     std::string s({"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp

@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class charT>
-void
+TEST_CONSTEXPR_CXX20 void
 test(unsigned n, charT c)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
@@ -36,7 +36,7 @@ test(unsigned n, charT c)
 }
 
 template <class charT, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(unsigned n, charT c, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
@@ -66,7 +66,7 @@ test(Tp n, Tp c)
 }
 
 template <class Tp, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(Tp n, Tp c, const A& a)
 {
     typedef char charT;
@@ -80,9 +80,8 @@ test(Tp n, Tp c, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
 
     test(0, 'a');
@@ -99,9 +98,9 @@ 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 >= 11
-    {
+  {
     typedef min_allocator<char> A;
 
     test(0, 'a');
@@ -118,7 +117,17 @@ 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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp

@@ -71,9 +71,8 @@ test(std::basic_string_view<charT> sv, const A& a)
   }
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
 
@@ -88,9 +87,9 @@ int main(int, char**)
 
     test(SV("123456798012345679801234567980123456798012345679801234567980"));
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A(2));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
 
@@ -105,7 +104,17 @@ int main(int, char**)
 
     test(SV("123456798012345679801234567980123456798012345679801234567980"));
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A());
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp

@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, SV sv)
 {
     typedef typename S::traits_type T;
@@ -28,9 +28,8 @@ test(S s1, SV sv)
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(""));
@@ -48,9 +47,9 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test(S(), SV(""));
@@ -68,7 +67,17 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

@@ -36,9 +36,8 @@
 #include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     std::string_view sv = "12345678901234";
     std::basic_string s1(sv);
     using S = decltype(s1); // what type did we get?
@@ -47,9 +46,9 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 
-    {
+  {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, std::allocator<char>{}};
     using S = decltype(s1); // what type did we get?
@@ -58,9 +57,9 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
+  {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, test_allocator<wchar_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -69,10 +68,10 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 #endif
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
-    {
+  {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, min_allocator<char8_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -81,9 +80,9 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 #endif
-    {
+  {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -92,8 +91,8 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
-    {
+  }
+  {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, explicit_allocator<char32_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -102,7 +101,17 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

@@ -40,9 +40,8 @@
 #include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4};
     using S = decltype(s1); // what type did we get?
@@ -51,9 +50,9 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 
-    {
+  {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4, std::allocator<char>{}};
     using S = decltype(s1); // what type did we get?
@@ -62,9 +61,9 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
+  {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, 0, 4, test_allocator<wchar_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -73,10 +72,10 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 #endif
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
-    {
+  {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char8_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -85,9 +84,9 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
 #endif
-    {
+  {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -96,8 +95,8 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
-    {
+  }
+  {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, 0, 4, explicit_allocator<char32_t>{}};
     using S = decltype(s1); // what type did we get?
@@ -106,7 +105,17 @@ int main(int, char**)
     static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp

@@ -28,7 +28,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos)
 {
     typedef typename S::traits_type T;
@@ -61,7 +61,7 @@ test(S str, unsigned pos)
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos, unsigned n)
 {
     typedef typename S::traits_type T;
@@ -93,7 +93,7 @@ test(S str, unsigned pos, unsigned n)
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
 {
     typedef typename S::traits_type T;
@@ -140,9 +140,8 @@ void test2583()
 #endif
 #endif
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 
@@ -179,9 +178,9 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 
@@ -218,12 +217,22 @@ int main(int, char**)
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
-    }
+  }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    test2583();
+  test2583();
 #endif
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }