[libc++] Prepare string.ops for constexpr

libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     typedef typename S::traits_type T;
     const typename S::value_type* str = s.c_str();
     if (s.size() > 0)
     {
         assert(T::compare(str, &s[0], s.size()) == 0);
         assert(T::eq(str[s.size()], typename S::value_type()));
     }
     else
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""));
     test(S("abcde"));
     test(S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""));
     test(S("abcde"));
     test(S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"));
-    }
 #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.ops/string.accessors/data.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_const(const S& s)
 {
     typedef typename S::traits_type T;
     const typename S::value_type* str = s.data();
     if (s.size() > 0)
     {
         assert(T::compare(str, &s[0], s.size()) == 0);
         assert(T::eq(str[s.size()], typename S::value_type()));
     }
     else
         assert(T::eq(str[0], typename S::value_type()));
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_nonconst(S& s)
 {
     typedef typename S::traits_type T;
     typename S::value_type* str = s.data();
     if (s.size() > 0)
     {
         assert(T::compare(str, &s[0], s.size()) == 0);
         assert(T::eq(str[s.size()], typename S::value_type()));
     }
     else
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test_const(S(""));
     test_const(S("abcde"));
     test_const(S("abcdefghij"));
     test_const(S("abcdefghijklmnopqrst"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test_const(S(""));
     test_const(S("abcde"));
     test_const(S("abcdefghij"));
     test_const(S("abcdefghijklmnopqrst"));
-    }
 #endif
 #if TEST_STD_VER > 14
-    {
     typedef std::string S;
     S s1("");                     test_nonconst(s1);
     S s2("abcde");                test_nonconst(s2);
     S s3("abcdefghij");           test_nonconst(s3);
     S s4("abcdefghijklmnopqrst"); test_nonconst(s4);
-    }
 #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.ops/string.accessors/get_allocator.pass.cpp

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::allocator_type& a)
 {
     assert(s.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());
     test(S("abcde", A(1)), A(1));
     test(S("abcdefghij", A(2)), A(2));
     test(S("abcdefghijklmnopqrst", A(3)), A(3));
-    }
 #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("abcde", A()), A());
     test(S("abcdefghij", A()), A());
     test(S("abcdefghijklmnopqrst", A()), 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.ops/string_compare/pointer.pass.cpp

 // int compare(const charT *s) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, int x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), "", 0);
     test(S(""), "abcde", -5);
     test(S(""), "abcdefghij", -10);
     test(S(""), "abcdefghijklmnopqrst", -20);
     test(S("abcde"), "", 5);
     test(S("abcde"), "abcde", 0);
     test(S("abcde"), "abcdefghij", -5);
     test(S("abcde"), "abcdefghijklmnopqrst", -15);
     test(S("abcdefghij"), "", 10);
     test(S("abcdefghij"), "abcde", 5);
     test(S("abcdefghij"), "abcdefghij", 0);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", -10);
     test(S("abcdefghijklmnopqrst"), "", 20);
     test(S("abcdefghijklmnopqrst"), "abcde", 15);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", 0);
     test(S(""), "abcde", -5);
     test(S(""), "abcdefghij", -10);
     test(S(""), "abcdefghijklmnopqrst", -20);
     test(S("abcde"), "", 5);
     test(S("abcde"), "abcde", 0);
     test(S("abcde"), "abcdefghij", -5);
     test(S("abcde"), "abcdefghijklmnopqrst", -15);
     test(S("abcdefghij"), "", 10);
     test(S("abcdefghij"), "abcde", 5);
     test(S("abcdefghij"), "abcdefghij", 0);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", -10);
     test(S("abcdefghijklmnopqrst"), "", 20);
     test(S("abcdefghijklmnopqrst"), "abcde", 15);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 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.ops/string_compare/size_size_T_size_size.pass.cpp

else
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, SV(""), 0, 0, 0);
     test(S(""), 0, 0, SV(""), 0, 1, 0);
     test(S(""), 0, 0, SV(""), 1, 0, 0);
     test(S(""), 0, 0, SV("abcde"), 0, 0, 0);
     test(S(""), 0, 0, SV("abcde"), 0, 1, -1);
     test(S(""), 0, 0, SV("abcde"), 0, 2, -2);
     test(S(""), 0, 0, SV("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, 1, SV("abcde"), 2, 3, -3);
     test(S(""), 0, 1, SV("abcde"), 2, 4, -3);
     test(S(""), 0, 1, SV("abcde"), 4, 0, 0);
     test(S(""), 0, 1, SV("abcde"), 4, 1, -1);
     test(S(""), 0, 1, SV("abcde"), 4, 2, -1);
     test(S(""), 0, 1, SV("abcde"), 5, 0, 0);
     test(S(""), 0, 1, SV("abcde"), 5, 1, 0);
     test(S(""), 0, 1, SV("abcde"), 6, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, 1, SV("abcdefghij"), 0, 0, 0);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 1, -1);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 5, -5);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 9, -9);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 10, -10);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 11, -10);
     test(S(""), 0, 1, SV("abcdefghij"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, 0, SV("abcdefghij"), 9, 0, 0);
     test(S(""), 1, 0, SV("abcdefghij"), 9, 1, 0);
     test(S(""), 1, 0, SV("abcdefghij"), 9, 2, 0);
     test(S(""), 1, 0, SV("abcdefghij"), 10, 0, 0);
     test(S(""), 1, 0, SV("abcdefghij"), 10, 1, 0);
     test(S(""), 1, 0, SV("abcdefghij"), 11, 0, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 1, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 19, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 1, 9, 0);
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcde"), 0, 0, SV("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcde"), 0, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcde"), 0, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcde"), 0, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 0, 1, SV(""), 0, 0, 1);
     test(S("abcde"), 0, 1, SV(""), 0, 1, 1);
     test(S("abcde"), 0, 1, SV(""), 1, 0, 0);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 0, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, 1, SV("abcde"), 0, 1, 0);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 2, -1);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 4, -3);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 5, -4);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 6, -4);
     test(S("abcde"), 0, 1, SV("abcde"), 1, 0, 1);
     test(S("abcde"), 0, 1, SV("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, 2, SV("abcde"), 4, 2, -4);
     test(S("abcde"), 0, 2, SV("abcde"), 5, 0, 2);
     test(S("abcde"), 0, 2, SV("abcde"), 5, 1, 2);
     test(S("abcde"), 0, 2, SV("abcde"), 6, 0, 0);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 0, 2);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 1, 1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 5, -3);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 9, -7);
+
+    return true;
 }
 
 template <class S, class SV>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 10, -8);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 11, -8);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 0, 2);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 1, -1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 4, -1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 8, -1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 0, 4, SV("abcdefghij"), 10, 1, 4);
     test(S("abcde"), 0, 4, SV("abcdefghij"), 11, 0, 0);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 0, 4);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 1, 3);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 10, -6);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 19, -15);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 20, -16);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 21, -16);
+
+    return true;
 }
 
 template <class S, class SV>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 19, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 20, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 10, 0, 4);
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 0, 6, SV(""), 0, 0, 5);
     test(S("abcde"), 0, 6, SV(""), 0, 1, 5);
     test(S("abcde"), 0, 6, SV(""), 1, 0, 0);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 0, 5);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 1, 4);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 2, 3);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 4, 1);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 5, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 0, 6, SV("abcde"), 0, 6, 0);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 0, 5);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 1, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 2, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 3, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 4, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 5, -1);
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 0, 0);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 1, -1);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 5, -5);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 10, -10);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 11, -10);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 0, 0);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 1, -1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 4, -4);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 8, -8);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 9, -9);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 10, -9);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 5, 0, 0);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 5, 1, -1);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 5, 2, -2);
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 18, -17);
+
+    return true;
 }
 
 template <class S, class SV>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 20, -18);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 1, 3, SV("abcde"), 0, 1, 1);
     test(S("abcde"), 1, 3, SV("abcde"), 0, 2, 1);
     test(S("abcde"), 1, 3, SV("abcde"), 0, 4, 1);
     test(S("abcde"), 1, 3, SV("abcde"), 0, 5, 1);
     test(S("abcde"), 1, 3, SV("abcde"), 0, 6, 1);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 0, 3);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 1, 2);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 2, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 1, 3, SV("abcde"), 1, 3, 0);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 4, -1);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 5, -1);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 0, 3);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 1, -1);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 2, -1);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 3, -1);
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 1, 4, SV("abcdefghij"), 0, 10, 1);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 0, 11, 1);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 0, 4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 1, 3);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 4, 0);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 8, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 9, -5);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 10, -5);
+
+    return true;
 }
 
 template <class S, class SV>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 0, 4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 1, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 2, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 4, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 5, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 6, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 9, 0, 4);
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 1, 3);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 9, -5);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 18, -14);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 19, -15);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 20, -15);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 1, -9);
+
+    return true;
 }
 
 template <class S, class SV>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 19, 1, -18);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 19, 2, -18);
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcde"), 2, 1, SV("abcde"), 0, 6, 2);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 0, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 1, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 2, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 3, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 4, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 5, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 0, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcde"), 2, 1, SV("abcde"), 2, 1, 0);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 2, -1);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 3, -2);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 4, -2);
     test(S("abcde"), 2, 1, SV("abcde"), 4, 0, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 4, 1, -2);
     test(S("abcde"), 2, 1, SV("abcde"), 4, 2, -2);
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcde"), 2, 2, SV("abcdefghij"), 1, 4, 1);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 1, 8, 1);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 1, 9, 1);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 1, 10, 1);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 0, 2);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 1, -3);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 2, -3);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 4, -3);
+
+    return true;
 }
 
 template <class S, class SV>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 5, -3);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 6, -3);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 9, 0, 2);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 9, 1, -7);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 9, 2, -7);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 10, 0, 2);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 10, 1, 2);
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 1, 19, 1);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 1, 20, 1);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 0, 3);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 1, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 5, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 9, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 10, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 11, -8);
+
+    return true;
 }
 
 template <class S, class SV>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 19, 0, 3);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 19, 1, -17);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 19, 2, -17);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 20, 0, 3);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 20, 1, 3);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 2, 4, SV(""), 0, 0, 3);
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcde"), 4, 0, SV("abcde"), 1, 3, -3);
     test(S("abcde"), 4, 0, SV("abcde"), 1, 4, -4);
     test(S("abcde"), 4, 0, SV("abcde"), 1, 5, -4);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 0, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 1, -1);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 2, -2);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 3, -3);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 4, -3);
+
+    return true;
 }
 
 template <class S, class SV>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcde"), 4, 0, SV("abcde"), 4, 0, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 4, 1, -1);
     test(S("abcde"), 4, 0, SV("abcde"), 4, 2, -1);
     test(S("abcde"), 4, 0, SV("abcde"), 5, 0, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 5, 1, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 6, 0, 0);
     test(S("abcde"), 4, 0, SV("abcdefghij"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 0, 1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 1, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 2, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 4, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 5, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 6, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 9, 0, 1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 9, 1, -5);
+
+    return true;
 }
 
 template <class S, class SV>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcde"), 4, 1, SV("abcdefghij"), 9, 2, -5);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 10, 0, 1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 10, 1, 1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 11, 0, 0);
     test(S("abcde"), 4, 1, SV("abcdefghijklmnopqrst"), 0, 0, 1);
     test(S("abcde"), 4, 1, SV("abcdefghijklmnopqrst"), 0, 1, 4);
     test(S("abcde"), 4, 1, SV("abcdefghijklmnopqrst"), 0, 10, 4);
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 10, 5, -6);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 10, 9, -6);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 10, 10, -6);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 10, 11, -6);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 19, 1, -15);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 19, 2, -15);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 20, 0, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 5, 0, SV(""), 0, 0, 0);
     test(S("abcde"), 5, 0, SV(""), 0, 1, 0);
     test(S("abcde"), 5, 0, SV(""), 1, 0, 0);
     test(S("abcde"), 5, 0, SV("abcde"), 0, 0, 0);
     test(S("abcde"), 5, 0, SV("abcde"), 0, 1, -1);
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcde"), 5, 1, SV("abcde"), 2, 1, -1);
     test(S("abcde"), 5, 1, SV("abcde"), 2, 2, -2);
     test(S("abcde"), 5, 1, SV("abcde"), 2, 3, -3);
     test(S("abcde"), 5, 1, SV("abcde"), 2, 4, -3);
     test(S("abcde"), 5, 1, SV("abcde"), 4, 0, 0);
     test(S("abcde"), 5, 1, SV("abcde"), 4, 1, -1);
     test(S("abcde"), 5, 1, SV("abcde"), 4, 2, -1);
     test(S("abcde"), 5, 1, SV("abcde"), 5, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcde"), 5, 1, SV("abcde"), 5, 1, 0);
     test(S("abcde"), 5, 1, SV("abcde"), 6, 0, 0);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 0, 0);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 1, -1);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 5, -5);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcde"), 6, 0, SV("abcdefghij"), 5, 5, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 5, 6, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 9, 0, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 9, 1, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 9, 2, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 10, 0, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 10, 1, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 11, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 1, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 19, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 0, 1, SV(""), 0, 0, 1);
     test(S("abcdefghij"), 0, 1, SV(""), 0, 1, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test20()
+TEST_CONSTEXPR_CXX20 bool test20()
 {
     test(S("abcdefghij"), 0, 1, SV(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 0, 1);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 1, 0);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 2, -1);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 4, -3);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 5, -4);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 6, -4);
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghij"), 0, 5, SV("abcde"), 4, 0, 5);
     test(S("abcdefghij"), 0, 5, SV("abcde"), 4, 1, -4);
     test(S("abcdefghij"), 0, 5, SV("abcde"), 4, 2, -4);
     test(S("abcdefghij"), 0, 5, SV("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 0, 5, SV("abcde"), 5, 1, 5);
     test(S("abcdefghij"), 0, 5, SV("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 0, 5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 1, 4);
+
+    return true;
 }
 
 template <class S, class SV>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 5, 0);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 9, -4);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 10, -5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 11, -5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 1, 0, 5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 1, 1, -1);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 1, 4, -1);
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghij"), 0, 9, SV("abcdefghij"), 9, 2, -9);
     test(S("abcdefghij"), 0, 9, SV("abcdefghij"), 10, 0, 9);
     test(S("abcdefghij"), 0, 9, SV("abcdefghij"), 10, 1, 9);
     test(S("abcdefghij"), 0, 9, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 0, 9);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 1, 8);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 10, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 19, -10);
+
+    return true;
 }
 
 template <class S, class SV>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 20, -11);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 21, -11);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 0, 9);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 19, -1);
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghij"), 0, 10, SV("abcdefghijklmnopqrst"), 20, 1, 10);
     test(S("abcdefghij"), 0, 10, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 0, 11, SV(""), 0, 0, 10);
     test(S("abcdefghij"), 0, 11, SV(""), 0, 1, 10);
     test(S("abcdefghij"), 0, 11, SV(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 0, 10);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 1, 9);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 2, 8);
+
+    return true;
 }
 
 template <class S, class SV>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 4, 6);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 5, 5);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 6, 5);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 0, 10);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 1, -1);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 2, -1);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 3, -1);
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghij"), 1, 0, SV("abcde"), 5, 1, 0);
     test(S("abcdefghij"), 1, 0, SV("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 0, 0);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 5, -5);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 9, -9);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 10, -10);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 11, -10);
+
+    return true;
 }
 
 template <class S, class SV>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 0, 0);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 1, -1);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 4, -4);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 8, -8);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 9, -9);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 10, -9);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 5, 0, 0);
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 0, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 1, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 1, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 18, -17);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 20, -18);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 5, -9);
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghij"), 1, 8, SV(""), 1, 0, 0);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 0, 8);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 1, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 2, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 4, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 5, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 6, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 0, 8);
+
+    return true;
 }
 
 template <class S, class SV>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 1, 7);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 2, 6);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 3, 5);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 2, 0, 8);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 2, 1, -1);
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 0, 5, 1);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 0, 9, 1);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 0, 10, 1);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 0, 11, 1);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 0, 9);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 1, 8);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 4, 5);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 8, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 9, 0);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 10, 0);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 0, 9);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 1, -4);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 2, -4);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 5, -4);
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 0, 9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 1, 8);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 9, 0);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 18, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 19, -10);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 20, -10);
+
+    return true;
 }
 
 template <class S, class SV>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 0, 9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 19, 0, 9);
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghij"), 5, 1, SV("abcde"), 0, 4, 5);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 0, 5, 5);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 0, 6, 5);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 0, 1);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 1, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 2, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 3, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 4, 4);
+
+    return true;
 }
 
 template <class S, class SV>
-void test29()
+TEST_CONSTEXPR_CXX20 bool test29()
 {
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 0, 1);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 2, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 4, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 4, 0, 1);
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 0, 2);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 1, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 4, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 8, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 9, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 10, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 0, 2);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 1, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 2, 0);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 4, -2);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 5, -3);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 6, -3);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 9, 0, 2);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 9, 1, -4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 9, 2, -4);
TEST_CONSTEXPR_CXX20 bool test30()
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 1, 9, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 1, 18, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 1, 19, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 1, 20, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 1, -5);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 9, -5);
+
+    return true;
 }
 
 template <class S, class SV>
-void test31()
+TEST_CONSTEXPR_CXX20 bool test31()
 {
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 11, -5);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 19, 1, -14);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 19, 2, -14);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 20, 0, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 20, 1, 4);
TEST_CONSTEXPR_CXX20 bool test31()
     test(S("abcdefghij"), 5, 6, SV("abcde"), 1, 1, 4);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 1, 2, 4);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 1, 3, 4);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 0, 5);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 2, 3);
+
+    return true;
 }
 
 template <class S, class SV>
-void test32()
+TEST_CONSTEXPR_CXX20 bool test32()
 {
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 4, 3);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 4, 0, 5);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 4, 1, 1);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 4, 2, 1);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 5, 1, 5);
TEST_CONSTEXPR_CXX20 bool test32()
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 1, 9, -9);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 1, 10, -9);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 0, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 1, -1);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 2, -2);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 5, -5);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 6, -5);
+
+    return true;
 }
 
 template <class S, class SV>
-void test33()
+TEST_CONSTEXPR_CXX20 bool test33()
 {
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 9, 1, -1);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 10, 0, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 bool test33()
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 1, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 5, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 9, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 10, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 11, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 19, 1, -10);
+
+    return true;
 }
 
 template <class S, class SV>
-void test34()
+TEST_CONSTEXPR_CXX20 bool test34()
 {
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 19, 2, -10);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 20, 0, 1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 9, 2, SV(""), 0, 0, 1);
     test(S("abcdefghij"), 9, 2, SV(""), 0, 1, 1);
     test(S("abcdefghij"), 9, 2, SV(""), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test34()
     test(S("abcdefghij"), 10, 0, SV("abcde"), 1, 5, -4);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 1, -1);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 2, -2);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 3, -3);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 4, -3);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 4, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 4, 1, -1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test35()
+TEST_CONSTEXPR_CXX20 bool test35()
 {
     test(S("abcdefghij"), 10, 0, SV("abcde"), 4, 2, -1);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 5, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 5, 1, 0);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcdefghij"), 0, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 10, 0, SV("abcdefghij"), 0, 5, -5);
TEST_CONSTEXPR_CXX20 bool test35()
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 5, 2, -2);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 5, 5, -5);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 5, 6, -5);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 9, 1, -1);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 10, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test36()
+TEST_CONSTEXPR_CXX20 bool test36()
 {
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 20, -20);
TEST_CONSTEXPR_CXX20 bool test36()
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 10, 10, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 10, 11, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test37()
+TEST_CONSTEXPR_CXX20 bool test37()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 2, -2);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 bool test37()
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 2, 3, -2);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 2, 4, -2);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 4, 1, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 4, 2, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 6, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test38()
+TEST_CONSTEXPR_CXX20 bool test38()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 5, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 9, -8);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 10, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 11, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 1, 0, 1);
TEST_CONSTEXPR_CXX20 bool test38()
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 9, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 9, 1, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 9, 2, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 10, 1, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 1, 9);
+
+    return true;
 }
 
 template <class S, class SV>
-void test39()
+TEST_CONSTEXPR_CXX20 bool test39()
 {
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 19, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 20, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 21, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 1, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test39()
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcdefghijklmnopqrst"), 19, 2, -19);
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcdefghijklmnopqrst"), 20, 0, 19);
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcdefghijklmnopqrst"), 20, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 0, 1, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 0, 20);
+
+    return true;
 }
 
 template <class S, class SV>
-void test40()
+TEST_CONSTEXPR_CXX20 bool test40()
 {
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 2, 18);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 4, 16);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 6, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 bool test40()
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcde"), 4, 2, -4);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcde"), 5, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcde"), 5, 1, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 9, 11);
+
+    return true;
 }
 
 template <class S, class SV>
-void test41()
+TEST_CONSTEXPR_CXX20 bool test41()
 {
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 11, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 4, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 8, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test41()
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghij"), 10, 1, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 20, -20);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 21, -20);
+
+    return true;
 }
 
 template <class S, class SV>
-void test42()
+TEST_CONSTEXPR_CXX20 bool test42()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 18, -18);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 20, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 10, 0, 0);
TEST_CONSTEXPR_CXX20 bool test42()
     test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), 0, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), 0, 1, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 1, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 2, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 4, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 5, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test43()
+TEST_CONSTEXPR_CXX20 bool test43()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 6, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 1, 8);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 2, 7);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 3, 6);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 4, 5);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 5, 5);
TEST_CONSTEXPR_CXX20 bool test43()
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 1, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 5, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 9, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 10, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 11, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 1, 17);
+
+    return true;
 }
 
 template <class S, class SV>
-void test44()
+TEST_CONSTEXPR_CXX20 bool test44()
 {
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 4, 14);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 8, 10);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 5, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 5, 1, -4);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 5, 2, -4);
TEST_CONSTEXPR_CXX20 bool test44()
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 1, 18);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 9, 10);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 18, 1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test45()
+TEST_CONSTEXPR_CXX20 bool test45()
 {
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 19, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 20, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 bool test45()
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 0, 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 0, 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 0, 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 0, 6, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 2, -2);
+
+    return true;
 }
 
 template <class S, class SV>
-void test46()
+TEST_CONSTEXPR_CXX20 bool test46()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 3, -3);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 5, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 3, -3);
TEST_CONSTEXPR_CXX20 bool test46()
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 0, 11, 10);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 8, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 10, 9);
+
+    return true;
 }
 
 template <class S, class SV>
-void test47()
+TEST_CONSTEXPR_CXX20 bool test47()
 {
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 1, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 4, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 6, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 9, 0, 1);
TEST_CONSTEXPR_CXX20 bool test47()
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 18, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 19, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 20, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 1, 4);
+
+    return true;
 }
 
 template <class S, class SV>
-void test48()
+TEST_CONSTEXPR_CXX20 bool test48()
 {
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 5, 0);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 9, -4);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 11, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 19, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 19, 1, -9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 19, 2, -9);
TEST_CONSTEXPR_CXX20 bool test48()
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 0, 6, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 2, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 3, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 5, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 0, 10);
+
+    return true;
 }
 
 template <class S, class SV>
-void test49()
+TEST_CONSTEXPR_CXX20 bool test49()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 1, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 2, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 3, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 4, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 4, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 4, 1, 6);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 4, 2, 6);
TEST_CONSTEXPR_CXX20 bool test49()
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 1, 8, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 1, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 4, 5);
+
+    return true;
 }
 
 template <class S, class SV>
-void test50()
+TEST_CONSTEXPR_CXX20 bool test50()
 {
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 6, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 9, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 9, 1, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 9, 2, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 10, 1, 10);
TEST_CONSTEXPR_CXX20 bool test50()
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 1, 19, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 1, 20, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 10, -10);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 11, -10);
+
+    return true;
 }
 
 template <class S, class SV>
-void test51()
+TEST_CONSTEXPR_CXX20 bool test51()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), 0, 0, 1);
TEST_CONSTEXPR_CXX20 bool test51()
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 1, 3, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 1, 4, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 1, 5, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 1, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 2, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 3, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 4, 17);
+
+    return true;
 }
 
 template <class S, class SV>
-void test52()
+TEST_CONSTEXPR_CXX20 bool test52()
 {
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 4, 1, 15);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 4, 2, 15);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcdefghij"), 0, 0, 1);
TEST_CONSTEXPR_CXX20 bool test52()
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 2, -2);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 4, -4);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 5, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 6, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 9, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 9, 1, -1);
+
+    return true;
 }
 
 template <class S, class SV>
-void test53()
+TEST_CONSTEXPR_CXX20 bool test53()
 {
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 9, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 10, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 10, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghijklmnopqrst"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 bool test53()
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 10, 10, -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 10, 11, -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 20, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test54()
+TEST_CONSTEXPR_CXX20 bool test54()
 {
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcde"), 0, 1, 0);
TEST_CONSTEXPR_CXX20 bool test54()
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 10, 10, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 10, 11, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
+
+    return true;
 }
 
 template <class S, class SV>
-void test55()
+TEST_CONSTEXPR_CXX20 bool test55()
 {
     test_npos(S(""), 0, 0, SV(""), 0, 0);
     test_npos(S(""), 0, 0, SV("abcde"), 0, -5);
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 0, -10);
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 1, -9);
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 5, -5);
+
+    return true;
 }
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const typename S::value_type* str, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
void test2()
     test(S("abcdefghijklmnopqrst"), 20, 1, "abcdefghij", -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, "abcdefghijklmnopqrst", -20);
     test(S("abcdefghijklmnopqrst"), 21, 0, "", 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcde", 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<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.ops/string_compare/size_size_pointer_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2, int x)
 {
     if (pos <= s.size())
         assert(sign(s.compare(pos, n1, str, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > s.size());
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, "", 0, 0);
     test(S(""), 0, 0, "abcde", 0, 0);
     test(S(""), 0, 0, "abcde", 1, -1);
     test(S(""), 0, 0, "abcde", 2, -2);
     test(S(""), 0, 0, "abcde", 4, -4);
     test(S(""), 0, 0, "abcde", 5, -5);
     test(S(""), 0, 0, "abcdefghij", 0, 0);
TEST_CONSTEXPR_CXX20 bool test0()
     test(S("abcde"), 0, 2, "abcdefghijklmnopqrst", 1, 1);
     test(S("abcde"), 0, 2, "abcdefghijklmnopqrst", 10, -8);
     test(S("abcde"), 0, 2, "abcdefghijklmnopqrst", 19, -17);
     test(S("abcde"), 0, 2, "abcdefghijklmnopqrst", 20, -18);
     test(S("abcde"), 0, 4, "", 0, 4);
     test(S("abcde"), 0, 4, "abcde", 0, 4);
     test(S("abcde"), 0, 4, "abcde", 1, 3);
     test(S("abcde"), 0, 4, "abcde", 2, 2);
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S("abcde"), 0, 4, "abcde", 4, 0);
     test(S("abcde"), 0, 4, "abcde", 5, -1);
     test(S("abcde"), 0, 4, "abcdefghij", 0, 4);
     test(S("abcde"), 0, 4, "abcdefghij", 1, 3);
     test(S("abcde"), 0, 4, "abcdefghij", 5, -1);
     test(S("abcde"), 0, 4, "abcdefghij", 9, -5);
     test(S("abcde"), 0, 4, "abcdefghij", 10, -6);
TEST_CONSTEXPR_CXX20 bool test1()
     test(S("abcde"), 1, 3, "", 0, 3);
     test(S("abcde"), 1, 3, "abcde", 0, 3);
     test(S("abcde"), 1, 3, "abcde", 1, 1);
     test(S("abcde"), 1, 3, "abcde", 2, 1);
     test(S("abcde"), 1, 3, "abcde", 4, 1);
     test(S("abcde"), 1, 3, "abcde", 5, 1);
     test(S("abcde"), 1, 3, "abcdefghij", 0, 3);
     test(S("abcde"), 1, 3, "abcdefghij", 1, 1);
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S("abcde"), 1, 3, "abcdefghij", 5, 1);
     test(S("abcde"), 1, 3, "abcdefghij", 9, 1);
     test(S("abcde"), 1, 3, "abcdefghij", 10, 1);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 0, 3);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 1, 1);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 10, 1);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 19, 1);
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcde"), 2, 3, "abcde", 4, 2);
     test(S("abcde"), 2, 3, "abcde", 5, 2);
     test(S("abcde"), 2, 3, "abcdefghij", 0, 3);
     test(S("abcde"), 2, 3, "abcdefghij", 1, 2);
     test(S("abcde"), 2, 3, "abcdefghij", 5, 2);
     test(S("abcde"), 2, 3, "abcdefghij", 9, 2);
     test(S("abcde"), 2, 3, "abcdefghij", 10, 2);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 0, 3);
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 1, 2);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 10, 2);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 19, 2);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 20, 2);
     test(S("abcde"), 2, 4, "", 0, 3);
     test(S("abcde"), 2, 4, "abcde", 0, 3);
     test(S("abcde"), 2, 4, "abcde", 1, 2);
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 5, 1, "abcdefghij", 5, -5);
     test(S("abcde"), 5, 1, "abcdefghij", 9, -9);
     test(S("abcde"), 5, 1, "abcdefghij", 10, -10);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 1, -1);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 10, -10);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 19, -19);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 20, -20);
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 6, 0, "", 0, 0);
     test(S("abcde"), 6, 0, "abcde", 0, 0);
     test(S("abcde"), 6, 0, "abcde", 1, 0);
     test(S("abcde"), 6, 0, "abcde", 2, 0);
     test(S("abcde"), 6, 0, "abcde", 4, 0);
     test(S("abcde"), 6, 0, "abcde", 5, 0);
     test(S("abcde"), 6, 0, "abcdefghij", 0, 0);
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcdefghij"), 0, 10, "abcdefghijklmnopqrst", 1, 9);
     test(S("abcdefghij"), 0, 10, "abcdefghijklmnopqrst", 10, 0);
     test(S("abcdefghij"), 0, 10, "abcdefghijklmnopqrst", 19, -9);
     test(S("abcdefghij"), 0, 10, "abcdefghijklmnopqrst", 20, -10);
     test(S("abcdefghij"), 0, 11, "", 0, 10);
     test(S("abcdefghij"), 0, 11, "abcde", 0, 10);
     test(S("abcdefghij"), 0, 11, "abcde", 1, 9);
     test(S("abcdefghij"), 0, 11, "abcde", 2, 8);
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcdefghij"), 0, 11, "abcde", 4, 6);
     test(S("abcdefghij"), 0, 11, "abcde", 5, 5);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 0, 10);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 1, 9);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 5, 5);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 9, 1);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 10, 0);
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcdefghij"), 1, 10, "", 0, 9);
     test(S("abcdefghij"), 1, 10, "abcde", 0, 9);
     test(S("abcdefghij"), 1, 10, "abcde", 1, 1);
     test(S("abcdefghij"), 1, 10, "abcde", 2, 1);
     test(S("abcdefghij"), 1, 10, "abcde", 4, 1);
     test(S("abcdefghij"), 1, 10, "abcde", 5, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 0, 9);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 1, 1);
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcdefghij"), 1, 10, "abcdefghij", 5, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 9, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 10, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 0, 9);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 1, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 10, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 19, 1);
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcdefghij"), 5, 6, "abcde", 4, 5);
     test(S("abcdefghij"), 5, 6, "abcde", 5, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 0, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 1, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 5, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 9, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 10, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 0, 5);
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 1, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 10, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 19, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 20, 5);
     test(S("abcdefghij"), 9, 0, "", 0, 0);
     test(S("abcdefghij"), 9, 0, "abcde", 0, 0);
     test(S("abcdefghij"), 9, 0, "abcde", 1, -1);
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcdefghij"), 11, 0, "abcdefghij", 5, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghij", 9, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghij", 10, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 1, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 10, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 19, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 20, 0);
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, "", 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 2, -2);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 4, -4);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 5, -5);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcdefghij", 0, 0);
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcdefghijklmnopqrst"), 0, 21, "abcdefghijklmnopqrst", 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 21, "abcdefghijklmnopqrst", 10, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, "abcdefghijklmnopqrst", 19, 1);
     test(S("abcdefghijklmnopqrst"), 0, 21, "abcdefghijklmnopqrst", 20, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "", 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 2, -2);
+
+    return true;
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 4, -4);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 5, -5);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 5, -5);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 10, -10);
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcdefghijklmnopqrst"), 10, 0, "", 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 1, -1);
+
+    return true;
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 9, -9);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 10, -10);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 10, -10);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 19, -19);
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcde", 4, -4);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcde", 5, -5);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 5, -5);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 9, -9);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 10, -10);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 10, -10);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 19, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 20, -20);
     test(S("abcdefghijklmnopqrst"), 19, 1, "", 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 1, "abcde", 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 1, "abcde", 1, 19);
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 5, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 9, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 10, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 10, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 19, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 20, 0);
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    }
+template <class S>
+void test() {
+
+  // static_assert(test0<S>());
+  // static_assert(test1<S>());
+  // static_assert(test2<S>());
+  // static_assert(test3<S>());
+  // static_assert(test4<S>());
+  // static_assert(test5<S>());
+  // static_assert(test6<S>());
+  // static_assert(test7<S>());
+  // static_assert(test8<S>());
+  // static_assert(test9<S>());
+  // static_assert(test10<S>());
+  // static_assert(test11<S>());
+
+int main(int, char**)
+  test<std::string>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

void test2()
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghij"), -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), -20);
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcde"), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghij"), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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
+  { // LWG 2946
     std::string s = " !";
     assert(s.compare(0, 1, {"abc", 1}) < 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.ops/string_compare/size_size_string_size_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s,   typename S::size_type pos1, typename S::size_type n1,
      const S& str, typename S::size_type pos2, typename S::size_type n2, int x)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
else
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, S(""), 0, 0, 0);
     test(S(""), 0, 0, S(""), 0, 1, 0);
     test(S(""), 0, 0, S(""), 1, 0, 0);
     test(S(""), 0, 0, S("abcde"), 0, 0, 0);
     test(S(""), 0, 0, S("abcde"), 0, 1, -1);
     test(S(""), 0, 0, S("abcde"), 0, 2, -2);
     test(S(""), 0, 0, S("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, 1, S("abcde"), 2, 3, -3);
     test(S(""), 0, 1, S("abcde"), 2, 4, -3);
     test(S(""), 0, 1, S("abcde"), 4, 0, 0);
     test(S(""), 0, 1, S("abcde"), 4, 1, -1);
     test(S(""), 0, 1, S("abcde"), 4, 2, -1);
     test(S(""), 0, 1, S("abcde"), 5, 0, 0);
     test(S(""), 0, 1, S("abcde"), 5, 1, 0);
     test(S(""), 0, 1, S("abcde"), 6, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, 1, S("abcdefghij"), 0, 0, 0);
     test(S(""), 0, 1, S("abcdefghij"), 0, 1, -1);
     test(S(""), 0, 1, S("abcdefghij"), 0, 5, -5);
     test(S(""), 0, 1, S("abcdefghij"), 0, 9, -9);
     test(S(""), 0, 1, S("abcdefghij"), 0, 10, -10);
     test(S(""), 0, 1, S("abcdefghij"), 0, 11, -10);
     test(S(""), 0, 1, S("abcdefghij"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, 0, S("abcdefghij"), 9, 0, 0);
     test(S(""), 1, 0, S("abcdefghij"), 9, 1, 0);
     test(S(""), 1, 0, S("abcdefghij"), 9, 2, 0);
     test(S(""), 1, 0, S("abcdefghij"), 10, 0, 0);
     test(S(""), 1, 0, S("abcdefghij"), 10, 1, 0);
     test(S(""), 1, 0, S("abcdefghij"), 11, 0, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 1, 0);
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 19, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 1, 9, 0);
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 0, 1, S(""), 0, 0, 1);
     test(S("abcde"), 0, 1, S(""), 0, 1, 1);
     test(S("abcde"), 0, 1, S(""), 1, 0, 0);
     test(S("abcde"), 0, 1, S("abcde"), 0, 0, 1);
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, 1, S("abcde"), 0, 1, 0);
     test(S("abcde"), 0, 1, S("abcde"), 0, 2, -1);
     test(S("abcde"), 0, 1, S("abcde"), 0, 4, -3);
     test(S("abcde"), 0, 1, S("abcde"), 0, 5, -4);
     test(S("abcde"), 0, 1, S("abcde"), 0, 6, -4);
     test(S("abcde"), 0, 1, S("abcde"), 1, 0, 1);
     test(S("abcde"), 0, 1, S("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, 2, S("abcde"), 4, 2, -4);
     test(S("abcde"), 0, 2, S("abcde"), 5, 0, 2);
     test(S("abcde"), 0, 2, S("abcde"), 5, 1, 2);
     test(S("abcde"), 0, 2, S("abcde"), 6, 0, 0);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 0, 2);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 1, 1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 5, -3);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 9, -7);
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 10, -8);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 11, -8);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 0, 2);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 1, -1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 4, -1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 8, -1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 0, 4, S("abcdefghij"), 10, 1, 4);
     test(S("abcde"), 0, 4, S("abcdefghij"), 11, 0, 0);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 0, 4);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 1, 3);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 10, -6);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 19, -15);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 20, -16);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 21, -16);
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 19, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 20, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 10, 0, 4);
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 0, 6, S(""), 0, 0, 5);
     test(S("abcde"), 0, 6, S(""), 0, 1, 5);
     test(S("abcde"), 0, 6, S(""), 1, 0, 0);
     test(S("abcde"), 0, 6, S("abcde"), 0, 0, 5);
     test(S("abcde"), 0, 6, S("abcde"), 0, 1, 4);
     test(S("abcde"), 0, 6, S("abcde"), 0, 2, 3);
     test(S("abcde"), 0, 6, S("abcde"), 0, 4, 1);
     test(S("abcde"), 0, 6, S("abcde"), 0, 5, 0);
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 0, 6, S("abcde"), 0, 6, 0);
     test(S("abcde"), 0, 6, S("abcde"), 1, 0, 5);
     test(S("abcde"), 0, 6, S("abcde"), 1, 1, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 2, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 3, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 4, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 5, -1);
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 0, 0);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 1, -1);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 5, -5);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 10, -10);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 11, -10);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 0, 0);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 1, -1);
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 4, -4);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 8, -8);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 9, -9);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 10, -9);
     test(S("abcde"), 1, 0, S("abcdefghij"), 5, 0, 0);
     test(S("abcde"), 1, 0, S("abcdefghij"), 5, 1, -1);
     test(S("abcde"), 1, 0, S("abcdefghij"), 5, 2, -2);
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 18, -17);
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 20, -18);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 1, 3, S("abcde"), 0, 1, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 2, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 4, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 5, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 6, 1);
     test(S("abcde"), 1, 3, S("abcde"), 1, 0, 3);
     test(S("abcde"), 1, 3, S("abcde"), 1, 1, 2);
     test(S("abcde"), 1, 3, S("abcde"), 1, 2, 1);
+
+    return true;
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 1, 3, S("abcde"), 1, 3, 0);
     test(S("abcde"), 1, 3, S("abcde"), 1, 4, -1);
     test(S("abcde"), 1, 3, S("abcde"), 1, 5, -1);
     test(S("abcde"), 1, 3, S("abcde"), 2, 0, 3);
     test(S("abcde"), 1, 3, S("abcde"), 2, 1, -1);
     test(S("abcde"), 1, 3, S("abcde"), 2, 2, -1);
     test(S("abcde"), 1, 3, S("abcde"), 2, 3, -1);
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 1, 4, S("abcdefghij"), 0, 10, 1);
     test(S("abcde"), 1, 4, S("abcdefghij"), 0, 11, 1);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 0, 4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 1, 3);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 4, 0);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 8, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 9, -5);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 10, -5);
+
+    return true;
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 0, 4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 1, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 2, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 4, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 5, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 6, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 9, 0, 4);
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 1, 3);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 9, -5);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 18, -14);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 19, -15);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 20, -15);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 1, -9);
+
+    return true;
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 19, 1, -18);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 19, 2, -18);
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcde"), 2, 1, S("abcde"), 0, 6, 2);
     test(S("abcde"), 2, 1, S("abcde"), 1, 0, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 1, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 2, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 3, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 4, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 5, 1);
     test(S("abcde"), 2, 1, S("abcde"), 2, 0, 1);
+
+    return true;
 }
 
 template <class S>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcde"), 2, 1, S("abcde"), 2, 1, 0);
     test(S("abcde"), 2, 1, S("abcde"), 2, 2, -1);
     test(S("abcde"), 2, 1, S("abcde"), 2, 3, -2);
     test(S("abcde"), 2, 1, S("abcde"), 2, 4, -2);
     test(S("abcde"), 2, 1, S("abcde"), 4, 0, 1);
     test(S("abcde"), 2, 1, S("abcde"), 4, 1, -2);
     test(S("abcde"), 2, 1, S("abcde"), 4, 2, -2);
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 4, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 8, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 9, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 10, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 0, 2);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 1, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 2, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 4, -3);
+
+    return true;
 }
 
 template <class S>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 5, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 6, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 9, 0, 2);
     test(S("abcde"), 2, 2, S("abcdefghij"), 9, 1, -7);
     test(S("abcde"), 2, 2, S("abcdefghij"), 9, 2, -7);
     test(S("abcde"), 2, 2, S("abcdefghij"), 10, 0, 2);
     test(S("abcde"), 2, 2, S("abcdefghij"), 10, 1, 2);
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 1, 19, 1);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 1, 20, 1);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 0, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 1, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 5, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 9, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 10, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 11, -8);
+
+    return true;
 }
 
 template <class S>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 0, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 1, -17);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 2, -17);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 20, 0, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 20, 1, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 2, 4, S(""), 0, 0, 3);
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcde"), 4, 0, S("abcde"), 1, 3, -3);
     test(S("abcde"), 4, 0, S("abcde"), 1, 4, -4);
     test(S("abcde"), 4, 0, S("abcde"), 1, 5, -4);
     test(S("abcde"), 4, 0, S("abcde"), 2, 0, 0);
     test(S("abcde"), 4, 0, S("abcde"), 2, 1, -1);
     test(S("abcde"), 4, 0, S("abcde"), 2, 2, -2);
     test(S("abcde"), 4, 0, S("abcde"), 2, 3, -3);
     test(S("abcde"), 4, 0, S("abcde"), 2, 4, -3);
+
+    return true;
 }
 
 template <class S>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcde"), 4, 0, S("abcde"), 4, 0, 0);
     test(S("abcde"), 4, 0, S("abcde"), 4, 1, -1);
     test(S("abcde"), 4, 0, S("abcde"), 4, 2, -1);
     test(S("abcde"), 4, 0, S("abcde"), 5, 0, 0);
     test(S("abcde"), 4, 0, S("abcde"), 5, 1, 0);
     test(S("abcde"), 4, 0, S("abcde"), 6, 0, 0);
     test(S("abcde"), 4, 0, S("abcdefghij"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 1, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 2, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 4, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 5, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 6, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 9, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 9, 1, -5);
+
+    return true;
 }
 
 template <class S>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcde"), 4, 1, S("abcdefghij"), 9, 2, -5);
     test(S("abcde"), 4, 1, S("abcdefghij"), 10, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 10, 1, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 11, 0, 0);
     test(S("abcde"), 4, 1, S("abcdefghijklmnopqrst"), 0, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghijklmnopqrst"), 0, 1, 4);
     test(S("abcde"), 4, 1, S("abcdefghijklmnopqrst"), 0, 10, 4);
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 5, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 9, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 10, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 11, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 19, 1, -15);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 19, 2, -15);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 20, 0, 1);
+
+    return true;
 }
 
 template <class S>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 5, 0, S(""), 0, 0, 0);
     test(S("abcde"), 5, 0, S(""), 0, 1, 0);
     test(S("abcde"), 5, 0, S(""), 1, 0, 0);
     test(S("abcde"), 5, 0, S("abcde"), 0, 0, 0);
     test(S("abcde"), 5, 0, S("abcde"), 0, 1, -1);
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcde"), 5, 1, S("abcde"), 2, 1, -1);
     test(S("abcde"), 5, 1, S("abcde"), 2, 2, -2);
     test(S("abcde"), 5, 1, S("abcde"), 2, 3, -3);
     test(S("abcde"), 5, 1, S("abcde"), 2, 4, -3);
     test(S("abcde"), 5, 1, S("abcde"), 4, 0, 0);
     test(S("abcde"), 5, 1, S("abcde"), 4, 1, -1);
     test(S("abcde"), 5, 1, S("abcde"), 4, 2, -1);
     test(S("abcde"), 5, 1, S("abcde"), 5, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcde"), 5, 1, S("abcde"), 5, 1, 0);
     test(S("abcde"), 5, 1, S("abcde"), 6, 0, 0);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 0, 0);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 1, -1);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 5, -5);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcde"), 6, 0, S("abcdefghij"), 5, 5, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 5, 6, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 9, 0, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 9, 1, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 9, 2, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 10, 0, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 11, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 1, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 19, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 0, 1, S(""), 0, 0, 1);
     test(S("abcdefghij"), 0, 1, S(""), 0, 1, 1);
+
+    return true;
 }
 
 template <class S>
-void test20()
+TEST_CONSTEXPR_CXX20 bool test20()
 {
     test(S("abcdefghij"), 0, 1, S(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 0, 1);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 1, 0);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 2, -1);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 4, -3);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 5, -4);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 6, -4);
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghij"), 0, 5, S("abcde"), 4, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcde"), 4, 1, -4);
     test(S("abcdefghij"), 0, 5, S("abcde"), 4, 2, -4);
     test(S("abcdefghij"), 0, 5, S("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcde"), 5, 1, 5);
     test(S("abcdefghij"), 0, 5, S("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 1, 4);
+
+    return true;
 }
 
 template <class S>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 5, 0);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 9, -4);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 10, -5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 11, -5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 1, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 1, 1, -1);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 1, 4, -1);
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 9, 2, -9);
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 10, 0, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 10, 1, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 0, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 1, 8);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 10, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 19, -10);
+
+    return true;
 }
 
 template <class S>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 20, -11);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 21, -11);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 0, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 19, -1);
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghij"), 0, 10, S("abcdefghijklmnopqrst"), 20, 1, 10);
     test(S("abcdefghij"), 0, 10, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 0, 11, S(""), 0, 0, 10);
     test(S("abcdefghij"), 0, 11, S(""), 0, 1, 10);
     test(S("abcdefghij"), 0, 11, S(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 0, 10);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 1, 9);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 2, 8);
+
+    return true;
 }
 
 template <class S>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 4, 6);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 5, 5);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 6, 5);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 0, 10);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 1, -1);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 2, -1);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 3, -1);
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghij"), 1, 0, S("abcde"), 5, 1, 0);
     test(S("abcdefghij"), 1, 0, S("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 0, 0);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 5, -5);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 9, -9);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 10, -10);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 11, -10);
+
+    return true;
 }
 
 template <class S>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 0, 0);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 1, -1);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 4, -4);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 8, -8);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 9, -9);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 10, -9);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 5, 0, 0);
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 0, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 1, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 1, 0);
+
+    return true;
 }
 
 template <class S>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 18, -17);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 20, -18);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 10, 5, -9);
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghij"), 1, 8, S(""), 1, 0, 0);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 0, 8);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 1, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 2, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 4, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 5, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 6, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 0, 8);
+
+    return true;
 }
 
 template <class S>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 1, 7);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 2, 6);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 3, 5);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 1, 8, S("abcde"), 2, 0, 8);
     test(S("abcdefghij"), 1, 8, S("abcde"), 2, 1, -1);
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 5, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 9, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 10, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 11, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 0, 9);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 1, 8);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 4, 5);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 8, 1);
+
+    return true;
 }
 
 template <class S>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 9, 0);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 10, 0);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 0, 9);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 1, -4);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 2, -4);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 5, -4);
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 0, 9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 1, 8);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 9, 0);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 18, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 19, -10);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 20, -10);
+
+    return true;
 }
 
 template <class S>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 0, 9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 19, 0, 9);
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghij"), 5, 1, S("abcde"), 0, 4, 5);
     test(S("abcdefghij"), 5, 1, S("abcde"), 0, 5, 5);
     test(S("abcdefghij"), 5, 1, S("abcde"), 0, 6, 5);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 0, 1);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 1, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 2, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 3, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 4, 4);
+
+    return true;
 }
 
 template <class S>
-void test29()
+TEST_CONSTEXPR_CXX20 bool test29()
 {
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 0, 1);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 2, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 4, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 4, 0, 1);
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 0, 2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 1, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 4, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 8, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 9, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 10, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 0, 2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 1, 1);
+
+    return true;
 }
 
 template <class S>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 2, 0);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 4, -2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 5, -3);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 6, -3);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 9, 0, 2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 9, 1, -4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 9, 2, -4);
TEST_CONSTEXPR_CXX20 bool test30()
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 9, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 18, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 19, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 20, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 1, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 9, -5);
+
+    return true;
 }
 
 template <class S>
-void test31()
+TEST_CONSTEXPR_CXX20 bool test31()
 {
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 11, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 19, 1, -14);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 19, 2, -14);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 20, 0, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 20, 1, 4);
TEST_CONSTEXPR_CXX20 bool test31()
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 1, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 2, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 3, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 0, 5);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 2, 3);
+
+    return true;
 }
 
 template <class S>
-void test32()
+TEST_CONSTEXPR_CXX20 bool test32()
 {
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 4, 3);
     test(S("abcdefghij"), 5, 6, S("abcde"), 4, 0, 5);
     test(S("abcdefghij"), 5, 6, S("abcde"), 4, 1, 1);
     test(S("abcdefghij"), 5, 6, S("abcde"), 4, 2, 1);
     test(S("abcdefghij"), 5, 6, S("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 5, 6, S("abcde"), 5, 1, 5);
TEST_CONSTEXPR_CXX20 bool test32()
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 1, 9, -9);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 1, 10, -9);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 1, -1);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 2, -2);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 5, -5);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 6, -5);
+
+    return true;
 }
 
 template <class S>
-void test33()
+TEST_CONSTEXPR_CXX20 bool test33()
 {
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 1, -1);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 10, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 bool test33()
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 1, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 5, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 9, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 10, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 11, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 19, 1, -10);
+
+    return true;
 }
 
 template <class S>
-void test34()
+TEST_CONSTEXPR_CXX20 bool test34()
 {
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 19, 2, -10);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 20, 0, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 9, 2, S(""), 0, 0, 1);
     test(S("abcdefghij"), 9, 2, S(""), 0, 1, 1);
     test(S("abcdefghij"), 9, 2, S(""), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test34()
     test(S("abcdefghij"), 10, 0, S("abcde"), 1, 5, -4);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 1, -1);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 2, -2);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 3, -3);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 4, -3);
     test(S("abcdefghij"), 10, 0, S("abcde"), 4, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 4, 1, -1);
+
+    return true;
 }
 
 template <class S>
-void test35()
+TEST_CONSTEXPR_CXX20 bool test35()
 {
     test(S("abcdefghij"), 10, 0, S("abcde"), 4, 2, -1);
     test(S("abcdefghij"), 10, 0, S("abcde"), 5, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 5, 1, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcdefghij"), 0, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 10, 0, S("abcdefghij"), 0, 5, -5);
TEST_CONSTEXPR_CXX20 bool test35()
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 2, -2);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 5, -5);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 6, -5);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 9, 1, -1);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 10, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test36()
+TEST_CONSTEXPR_CXX20 bool test36()
 {
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 20, -20);
TEST_CONSTEXPR_CXX20 bool test36()
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 10, 10, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 10, 11, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test37()
+TEST_CONSTEXPR_CXX20 bool test37()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 2, -2);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 bool test37()
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 2, 3, -2);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 2, 4, -2);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 4, 1, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 4, 2, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 6, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test38()
+TEST_CONSTEXPR_CXX20 bool test38()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 5, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 9, -8);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 10, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 11, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 1, 0, 1);
TEST_CONSTEXPR_CXX20 bool test38()
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 9, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 9, 1, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 9, 2, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 10, 1, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 1, 9);
+
+    return true;
 }
 
 template <class S>
-void test39()
+TEST_CONSTEXPR_CXX20 bool test39()
 {
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 19, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 20, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 21, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 1, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test39()
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 19, 2, -19);
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 20, 0, 19);
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 20, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 0, 1, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 0, 20);
+
+    return true;
 }
 
 template <class S>
-void test40()
+TEST_CONSTEXPR_CXX20 bool test40()
 {
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 2, 18);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 4, 16);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 6, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 bool test40()
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 4, 2, -4);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 5, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 5, 1, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 9, 11);
+
+    return true;
 }
 
 template <class S>
-void test41()
+TEST_CONSTEXPR_CXX20 bool test41()
 {
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 11, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 4, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 8, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test41()
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 20, -20);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 21, -20);
+
+    return true;
 }
 
 template <class S>
-void test42()
+TEST_CONSTEXPR_CXX20 bool test42()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 18, -18);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 20, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 10, 0, 0);
TEST_CONSTEXPR_CXX20 bool test42()
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 0, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 0, 1, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 1, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 2, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 4, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 5, 1);
+
+    return true;
 }
 
 template <class S>
-void test43()
+TEST_CONSTEXPR_CXX20 bool test43()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 6, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 1, 8);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 2, 7);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 3, 6);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 4, 5);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 5, 5);
TEST_CONSTEXPR_CXX20 bool test43()
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 1, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 5, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 9, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 10, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 11, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 1, 17);
+
+    return true;
 }
 
 template <class S>
-void test44()
+TEST_CONSTEXPR_CXX20 bool test44()
 {
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 4, 14);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 8, 10);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 5, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 5, 1, -4);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 5, 2, -4);
TEST_CONSTEXPR_CXX20 bool test44()
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 1, 18);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 9, 10);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 18, 1);
+
+    return true;
 }
 
 template <class S>
-void test45()
+TEST_CONSTEXPR_CXX20 bool test45()
 {
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 19, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 20, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 bool test45()
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 6, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 2, -2);
+
+    return true;
 }
 
 template <class S>
-void test46()
+TEST_CONSTEXPR_CXX20 bool test46()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 3, -3);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 5, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 3, -3);
TEST_CONSTEXPR_CXX20 bool test46()
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 0, 11, 10);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 8, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 10, 9);
+
+    return true;
 }
 
 template <class S>
-void test47()
+TEST_CONSTEXPR_CXX20 bool test47()
 {
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 1, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 4, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 6, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 9, 0, 1);
TEST_CONSTEXPR_CXX20 bool test47()
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 18, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 19, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 20, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 1, 4);
+
+    return true;
 }
 
 template <class S>
-void test48()
+TEST_CONSTEXPR_CXX20 bool test48()
 {
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 5, 0);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 9, -4);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 11, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 19, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 19, 1, -9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 19, 2, -9);
TEST_CONSTEXPR_CXX20 bool test48()
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 0, 6, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 2, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 3, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 5, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 0, 10);
+
+    return true;
 }
 
 template <class S>
-void test49()
+TEST_CONSTEXPR_CXX20 bool test49()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 1, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 2, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 3, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 4, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 4, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 4, 1, 6);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 4, 2, 6);
TEST_CONSTEXPR_CXX20 bool test49()
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 8, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 1, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 4, 5);
+
+    return true;
 }
 
 template <class S>
-void test50()
+TEST_CONSTEXPR_CXX20 bool test50()
 {
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 6, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 9, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 9, 1, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 9, 2, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 10, 1, 10);
TEST_CONSTEXPR_CXX20 bool test50()
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 1, 19, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 1, 20, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 10, -10);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 11, -10);
+
+    return true;
 }
 
 template <class S>
-void test51()
+TEST_CONSTEXPR_CXX20 bool test51()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 1, S(""), 0, 0, 1);
TEST_CONSTEXPR_CXX20 bool test51()
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 1, 3, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 1, 4, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 1, 5, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 1, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 2, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 3, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 4, 17);
+
+    return true;
 }
 
 template <class S>
-void test52()
+TEST_CONSTEXPR_CXX20 bool test52()
 {
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 1, 15);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 2, 15);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcdefghij"), 0, 0, 1);
TEST_CONSTEXPR_CXX20 bool test52()
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 2, -2);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 5, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 6, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 9, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 9, 1, -1);
+
+    return true;
 }
 
 template <class S>
-void test53()
+TEST_CONSTEXPR_CXX20 bool test53()
 {
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 9, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 10, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 bool test53()
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 10, -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 11, -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 20, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test54()
+TEST_CONSTEXPR_CXX20 bool test54()
 {
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcde"), 0, 1, 0);
TEST_CONSTEXPR_CXX20 bool test54()
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 10, 10, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 10, 11, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
+
+    return true;
 }
 
 template<class S>
-void test55()
+TEST_CONSTEXPR_CXX20 bool test55()
 {
     test_npos(S(""), 0, 0, S(""), 0, 0);
     test_npos(S(""), 0, 0, S("abcde"), 0, -5);
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 0, -10);
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 1, -9);
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 5, -5);
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    test12<S>();
-    test13<S>();
-    test14<S>();
-    test15<S>();
-    test16<S>();
-    test17<S>();
-    test18<S>();
-    test19<S>();
-    test20<S>();
-    test21<S>();
-    test22<S>();
-    test23<S>();
-    test24<S>();
-    test25<S>();
-    test26<S>();
-    test27<S>();
-    test28<S>();
-    test29<S>();
-    test30<S>();
-    test31<S>();
-    test32<S>();
-    test33<S>();
-    test34<S>();
-    test35<S>();
-    test36<S>();
-    test37<S>();
-    test38<S>();
-    test39<S>();
-    test40<S>();
-    test41<S>();
-    test42<S>();
-    test43<S>();
-    test44<S>();
-    test45<S>();
-    test46<S>();
-    test47<S>();
-    test48<S>();
-    test49<S>();
-    test50<S>();
-    test51<S>();
-    test52<S>();
-    test53<S>();
-    test54<S>();
-    test55<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    test12<S>();
-    test13<S>();
-    test14<S>();
-    test15<S>();
-    test16<S>();
-    test17<S>();
-    test18<S>();
-    test19<S>();
-    test20<S>();
-    test21<S>();
-    test22<S>();
-    test23<S>();
-    test24<S>();
-    test25<S>();
-    test26<S>();
-    test27<S>();
-    test28<S>();
-    test29<S>();
-    test30<S>();
-    test31<S>();
-    test32<S>();
-    test33<S>();
-    test34<S>();
-    test35<S>();
-    test36<S>();
-    test37<S>();
-    test38<S>();
-    test39<S>();
-    test40<S>();
-    test41<S>();
-    test42<S>();
-    test43<S>();
-    test44<S>();
-    test45<S>();
-    test46<S>();
-    test47<S>();
-    test48<S>();
-    test49<S>();
-    test50<S>();
-    test51<S>();
-    test52<S>();
-    test53<S>();
-    test54<S>();
-    test55<S>();
-    }
+template <class S>
+void test() {
+
+  // static_assert(test0<S>());
+  // static_assert(test1<S>());
+  // static_assert(test2<S>());
+  // static_assert(test3<S>());
+  // static_assert(test4<S>());
+  // static_assert(test5<S>());
+  // static_assert(test6<S>());
+  // static_assert(test7<S>());
+  // static_assert(test8<S>());
+  // static_assert(test9<S>());
+  // static_assert(test10<S>());
+  // static_assert(test11<S>());
+  // static_assert(test12<S>());
+  // static_assert(test13<S>());
+  // static_assert(test14<S>());
+  // static_assert(test15<S>());
+  // static_assert(test16<S>());
+  // static_assert(test17<S>());
+  // static_assert(test18<S>());
+  // static_assert(test19<S>());
+  // static_assert(test20<S>());
+  // static_assert(test21<S>());
+  // static_assert(test22<S>());
+  // static_assert(test23<S>());
+  // static_assert(test24<S>());
+  // static_assert(test25<S>());
+  // static_assert(test26<S>());
+  // static_assert(test27<S>());
+  // static_assert(test28<S>());
+  // static_assert(test29<S>());
+  // static_assert(test30<S>());
+  // static_assert(test31<S>());
+  // static_assert(test32<S>());
+  // static_assert(test33<S>());
+  // static_assert(test34<S>());
+  // static_assert(test35<S>());
+  // static_assert(test36<S>());
+  // static_assert(test37<S>());
+  // static_assert(test38<S>());
+  // static_assert(test39<S>());
+  // static_assert(test40<S>());
+  // static_assert(test41<S>());
+  // static_assert(test42<S>());
+  // static_assert(test43<S>());
+  // static_assert(test44<S>());
+  // static_assert(test45<S>());
+  // static_assert(test46<S>());
+  // static_assert(test47<S>());
+  // static_assert(test48<S>());
+  // static_assert(test49<S>());
+  // static_assert(test50<S>());
+  // static_assert(test51<S>());
+  // static_assert(test52<S>());
+  // static_assert(test53<S>());
+  // static_assert(test54<S>());
+  // static_assert(test55<S>());
+
+int main(int, char**)
+  test<std::string>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, sv)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > s.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, SV(""), 0);
     test(S(""), 0, 0, SV("abcde"), -5);
     test(S(""), 0, 0, SV("abcdefghij"), -10);
     test(S(""), 0, 0, SV("abcdefghijklmnopqrst"), -20);
     test(S(""), 0, 1, SV(""), 0);
     test(S(""), 0, 1, SV("abcde"), -5);
     test(S(""), 0, 1, SV("abcdefghij"), -10);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 5, 0, SV("abcdefghijklmnopqrst"), -20);
     test(S("abcde"), 5, 1, SV(""), 0);
     test(S("abcde"), 5, 1, SV("abcde"), -5);
     test(S("abcde"), 5, 1, SV("abcdefghij"), -10);
     test(S("abcde"), 5, 1, SV("abcdefghijklmnopqrst"), -20);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, SV(""), 0);
     test(S("abcde"), 6, 0, SV("abcde"), 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0);
     test(S("abcdefghij"), 0, 0, SV(""), 0);
     test(S("abcdefghij"), 0, 0, SV("abcde"), -5);
     test(S("abcdefghij"), 0, 0, SV("abcdefghij"), -10);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), -20);
     test(S("abcdefghij"), 11, 0, SV(""), 0);
     test(S("abcdefghij"), 11, 0, SV("abcde"), 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghij"), 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 0);
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), -5);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcdefghij"), -10);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcdefghijklmnopqrst"), -20);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV(""), 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), -9);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghij"), -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), -20);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcde"), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghij"), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
-    }
 #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.ops/string_compare/string.pass.cpp

 // int compare(const basic_string& str) const
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, int x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), -5);
     test(S(""), S("abcdefghij"), -10);
     test(S(""), S("abcdefghijklmnopqrst"), -20);
     test(S("abcde"), S(""), 5);
     test(S("abcde"), S("abcde"), 0);
     test(S("abcde"), S("abcdefghij"), -5);
     test(S("abcde"), S("abcdefghijklmnopqrst"), -15);
     test(S("abcdefghij"), S(""), 10);
     test(S("abcdefghij"), S("abcde"), 5);
     test(S("abcdefghij"), S("abcdefghij"), 0);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), -10);
     test(S("abcdefghijklmnopqrst"), S(""), 20);
     test(S("abcdefghijklmnopqrst"), S("abcde"), 15);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 0);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), -5);
     test(S(""), S("abcdefghij"), -10);
     test(S(""), S("abcdefghijklmnopqrst"), -20);
     test(S("abcde"), S(""), 5);
     test(S("abcde"), S("abcde"), 0);
     test(S("abcde"), S("abcdefghij"), -5);
     test(S("abcde"), S("abcdefghijklmnopqrst"), -15);
     test(S("abcdefghij"), S(""), 10);
     test(S("abcdefghij"), S("abcde"), 5);
     test(S("abcdefghij"), S("abcdefghij"), 0);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), -10);
     test(S("abcdefghijklmnopqrst"), S(""), 20);
     test(S("abcdefghijklmnopqrst"), S("abcde"), 15);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 0);
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
+  { // LWG 2946
     std::string s = " !";
     assert(s.compare({"abc", 1}) < 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.ops/string_compare/string_view.pass.cpp

 // int compare(const basic_string_view sv) const
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, int x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.compare(sv));
     assert(sign(s.compare(sv)) == sign(x));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(""), SV(""), 0);
     test(S(""), SV("abcde"), -5);
     test(S(""), SV("abcdefghij"), -10);
     test(S(""), SV("abcdefghijklmnopqrst"), -20);
     test(S("abcde"), SV(""), 5);
     test(S("abcde"), SV("abcde"), 0);
     test(S("abcde"), SV("abcdefghij"), -5);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), -15);
     test(S("abcdefghij"), SV(""), 10);
     test(S("abcdefghij"), SV("abcde"), 5);
     test(S("abcdefghij"), SV("abcdefghij"), 0);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), -10);
     test(S("abcdefghijklmnopqrst"), SV(""), 20);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), 15);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
-    }
 #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(""), 0);
     test(S(""), SV("abcde"), -5);
     test(S(""), SV("abcdefghij"), -10);
     test(S(""), SV("abcdefghijklmnopqrst"), -20);
     test(S("abcde"), SV(""), 5);
     test(S("abcde"), SV("abcde"), 0);
     test(S("abcde"), SV("abcdefghij"), -5);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), -15);
     test(S("abcdefghij"), SV(""), 10);
     test(S("abcdefghij"), SV("abcde"), 5);
     test(S("abcdefghij"), SV("abcdefghij"), 0);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), -10);
     test(S("abcdefghijklmnopqrst"), SV(""), 20);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), 15);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 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.ops/string_find.first.not.of/char_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c, pos));
     assert(s.find_first_not_of(c, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c));
     assert(s.find_first_not_of(c) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 'q', 0, S::npos);
     test(S(""), 'q', 1, S::npos);
     test(S("kitcj"), 'q', 0, 0);
     test(S("qkamf"), 'q', 1, 1);
     test(S("nhmko"), 'q', 2, 2);
     test(S("tpsaf"), 'q', 4, 4);
     test(S("lahfb"), 'q', 5, S::npos);
bool test() {
     test(S("oselktgbcapndfjihrmq"), 'q', 21, S::npos);
 
     test(S(""), 'q', S::npos);
     test(S("q"), 'q', S::npos);
     test(S("qqq"), 'q', S::npos);
     test(S("csope"), 'q', 0);
     test(S("gfsmthlkon"), 'q', 0);
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'q', 0, S::npos);
     test(S(""), 'q', 1, S::npos);
     test(S("kitcj"), 'q', 0, 0);
     test(S("qkamf"), 'q', 1, 1);
     test(S("nhmko"), 'q', 2, 2);
     test(S("tpsaf"), 'q', 4, 4);
     test(S("lahfb"), 'q', 5, S::npos);
#if TEST_STD_VER >= 11
     test(S("oselktgbcapndfjihrmq"), 'q', 21, S::npos);
 
     test(S(""), 'q', S::npos);
     test(S("q"), 'q', S::npos);
     test(S("qqq"), 'q', S::npos);
     test(S("csope"), 'q', 0);
     test(S("gfsmthlkon"), 'q', 0);
     test(S("laenfsbridchgotmkqpj"), 'q', 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.ops/string_find.first.not.of/pointer_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
     assert(s.find_first_not_of(str, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     assert(s.find_first_not_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
     test(S(""), "pqlnkmbdjo", 0, S::npos);
     test(S(""), "qkamfogpnljdcshbreti", 0, S::npos);
     test(S(""), "", 1, S::npos);
     test(S(""), "bjaht", 1, S::npos);
     test(S(""), "hjlcmgpket", 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), "lsckfnqgdahejiopbtmr", 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), "", 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), "gfsrt", 21, S::npos);
     test(S("latkmisecnorjbfhqpdg"), "pfsocbhjtm", 21, S::npos);
     test(S("lecfratdjkhnsmqpoigb"), "tpflmdnoicjgkberhqsa", 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
     test(S(""), "pqlnkmbdjo", S::npos);
     test(S(""), "qkamfogpnljdcshbreti", S::npos);
     test(S("nhmko"), "", 0);
     test(S("lahfb"), "irkhs", 0);
     test(S("gmfhd"), "kantesmpgj", 2);
     test(S("odaft"), "oknlrstdpiqmjbaghcfe", S::npos);
     test(S("eolhfgpjqk"), "", 0);
     test(S("nbatdlmekr"), "bnrpe", 2);
     test(S("jdmciepkaq"), "jtdaefblso", 2);
     test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", S::npos);
     test(S("gprdcokbnjhlsfmtieqa"), "", 0);
     test(S("qjghlnftcaismkropdeb"), "bjaht", 0);
     test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 1);
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<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.ops/string_find.first.not.of/pointer_size_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos, n));
     assert(s.find_first_not_of(str, pos, n) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
     test(S(""), "kante", 0, 1, S::npos);
     test(S(""), "oknlr", 0, 2, S::npos);
     test(S(""), "pcdro", 0, 4, S::npos);
     test(S(""), "bnrpe", 0, 5, S::npos);
     test(S(""), "jtdaefblso", 0, 0, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("fthqm"), "dmasojntqleribkgfchp", 4, 20, S::npos);
     test(S("klopi"), "", 5, 0, S::npos);
     test(S("dajhn"), "psthd", 5, 0, S::npos);
     test(S("jbgno"), "rpmjd", 5, 1, S::npos);
     test(S("hkjae"), "dfsmk", 5, 2, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, S::npos);
     test(S("ktdor"), "kipnf", 5, 5, S::npos);
     test(S("ldprn"), "hmrnqdgifl", 5, 0, S::npos);
     test(S("egmjk"), "fsmjcdairn", 5, 1, S::npos);
     test(S("armql"), "pcdgltbrfj", 5, 5, S::npos);
     test(S("cdhjo"), "aekfctpirg", 5, 9, S::npos);
     test(S("jcons"), "ledihrsgpf", 5, 10, S::npos);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("gqtjsbdckh"), "otdma", 10, 2, S::npos);
     test(S("cfkqpjlegi"), "efhjg", 10, 4, S::npos);
     test(S("beanrfodgj"), "odpte", 10, 5, S::npos);
     test(S("adtkqpbjfi"), "bctdgfmolr", 10, 0, S::npos);
     test(S("iomkfthagj"), "oaklidrbqg", 10, 1, S::npos);
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, S::npos);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, S::npos);
     test(S("bmeqgcdorj"), "pjqonlebsf", 10, 10, S::npos);
     test(S("etqlcanmob"), "dshmnbtolcjepgaikfqr", 10, 0, S::npos);
     test(S("roqmkbdtia"), "iogfhpabtjkqlrnemcds", 10, 1, S::npos);
     test(S("kadsithljf"), "ngridfabjsecpqltkmoh", 10, 10, S::npos);
     test(S("sgtkpbfdmh"), "athmknplcgofrqejsdib", 10, 19, S::npos);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("focalnrpiqmdkstehbjg"), "apiblotgcd", 20, 1, S::npos);
     test(S("rhqdspkmebiflcotnjga"), "acfhdenops", 20, 5, S::npos);
     test(S("rahdtmsckfboqlpniegj"), "jopdeamcrk", 20, 9, S::npos);
     test(S("fbkeiopclstmdqranjhg"), "trqncbkgmh", 20, 10, S::npos);
     test(S("lifhpdgmbconstjeqark"), "tomglrkencbsfjqpihda", 20, 0, S::npos);
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, S::npos);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, S::npos);
     test(S("sirfgmjqhctndbklaepo"), "ohkmdpfqbsacrtjnlgei", 20, 19, S::npos);
     test(S("rlbdsiceaonqjtfpghkm"), "dlbrteoisgphmkncajfq", 20, 20, S::npos);
     test(S("ecgdanriptblhjfqskom"), "", 21, 0, S::npos);
     test(S("fdmiarlpgcskbhoteqjn"), "sjrlo", 21, 0, S::npos);
     test(S("rlbstjqopignecmfadkh"), "qjpor", 21, 1, S::npos);
     test(S("grjpqmbshektdolcafni"), "odhfn", 21, 2, S::npos);
     test(S("sakfcohtqnibprjmlged"), "qtfin", 21, 4, S::npos);
     test(S("mjtdglasihqpocebrfkn"), "hpqfo", 21, 5, S::npos);
     test(S("okaplfrntghqbmeicsdj"), "fabmertkos", 21, 0, S::npos);
     test(S("sahngemrtcjidqbklfpo"), "brqtgkmaej", 21, 1, S::npos);
     test(S("dlmsipcnekhbgoaftqjr"), "nfrdeihsgl", 21, 5, S::npos);
     test(S("ahegrmqnoiklpfsdbcjt"), "hlfrosekpi", 21, 9, S::npos);
     test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, S::npos);
     test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, S::npos);
     test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, S::npos);
     test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, S::npos);
     test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, S::npos);
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<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.ops/string_find.first.not.of/string_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
     assert(s.find_first_not_of(str, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str));
     assert(s.find_first_not_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
     test(S(""), S("pqlnkmbdjo"), 0, S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), S(""), 1, S::npos);
     test(S(""), S("bjaht"), 1, S::npos);
     test(S(""), S("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), S("lsckfnqgdahejiopbtmr"), 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), S(""), 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), S("gfsrt"), 21, S::npos);
     test(S("latkmisecnorjbfhqpdg"), S("pfsocbhjtm"), 21, S::npos);
     test(S("lecfratdjkhnsmqpoigb"), S("tpflmdnoicjgkberhqsa"), 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
     test(S(""), S("pqlnkmbdjo"), S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), S(""), 0);
     test(S("lahfb"), S("irkhs"), 0);
     test(S("gmfhd"), S("kantesmpgj"), 2);
     test(S("odaft"), S("oknlrstdpiqmjbaghcfe"), S::npos);
     test(S("eolhfgpjqk"), S(""), 0);
     test(S("nbatdlmekr"), S("bnrpe"), 2);
     test(S("jdmciepkaq"), S("jtdaefblso"), 2);
     test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), S::npos);
     test(S("gprdcokbnjhlsfmtieqa"), S(""), 0);
     test(S("qjghlnftcaismkropdeb"), S("bjaht"), 0);
     test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 1);
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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
+  { // LWG 2946
     std::string s = " !";
     assert(s.find_first_not_of({"abc", 1}) == 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.ops/string_find.first.not.of/string_view_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(sv, pos));
     assert(s.find_first_not_of(sv, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(sv));
     assert(s.find_first_not_of(sv) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, S::npos);
     test(S(""), SV("laenf"), 0, S::npos);
     test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), SV(""), 1, S::npos);
     test(S(""), SV("bjaht"), 1, S::npos);
     test(S(""), SV("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, S::npos);
     test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, S::npos);
     test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, S::npos);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
     test(S(""), SV("pqlnkmbdjo"), S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), SV(""), 0);
     test(S("lahfb"), SV("irkhs"), 0);
     test(S("gmfhd"), SV("kantesmpgj"), 2);
     test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), S::npos);
     test(S("eolhfgpjqk"), SV(""), 0);
     test(S("nbatdlmekr"), SV("bnrpe"), 2);
     test(S("jdmciepkaq"), SV("jtdaefblso"), 2);
     test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), S::npos);
     test(S("gprdcokbnjhlsfmtieqa"), SV(""), 0);
     test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 0);
     test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 1);
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c, pos));
     assert(s.find_first_of(c, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c));
     assert(s.find_first_of(c) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 'e', 0, S::npos);
     test(S(""), 'e', 1, S::npos);
     test(S("kitcj"), 'e', 0, S::npos);
     test(S("qkamf"), 'e', 1, S::npos);
     test(S("nhmko"), 'e', 2, S::npos);
     test(S("tpsaf"), 'e', 4, S::npos);
     test(S("lahfb"), 'e', 5, S::npos);
bool test() {
     test(S("jtdaefblsokrmhpgcnqi"), 'e', 19, S::npos);
     test(S("hkbgspofltajcnedqmri"), 'e', 20, S::npos);
     test(S("oselktgbcapndfjihrmq"), 'e', 21, S::npos);
 
     test(S(""), 'e', S::npos);
     test(S("csope"), 'e', 4);
     test(S("gfsmthlkon"), 'e', S::npos);
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'e', 0, S::npos);
     test(S(""), 'e', 1, S::npos);
     test(S("kitcj"), 'e', 0, S::npos);
     test(S("qkamf"), 'e', 1, S::npos);
     test(S("nhmko"), 'e', 2, S::npos);
     test(S("tpsaf"), 'e', 4, S::npos);
     test(S("lahfb"), 'e', 5, S::npos);
#if TEST_STD_VER >= 11
     test(S("jtdaefblsokrmhpgcnqi"), 'e', 19, S::npos);
     test(S("hkbgspofltajcnedqmri"), 'e', 20, S::npos);
     test(S("oselktgbcapndfjihrmq"), 'e', 21, S::npos);
 
     test(S(""), 'e', S::npos);
     test(S("csope"), 'e', 4);
     test(S("gfsmthlkon"), 'e', S::npos);
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
-    }
 #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.ops/string_find.first.of/pointer_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
     assert(s.find_first_of(str, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
     assert(s.find_first_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
     test(S(""), "pqlnkmbdjo", 0, S::npos);
     test(S(""), "qkamfogpnljdcshbreti", 0, S::npos);
     test(S(""), "", 1, S::npos);
     test(S(""), "bjaht", 1, S::npos);
     test(S(""), "hjlcmgpket", 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), "lsckfnqgdahejiopbtmr", 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), "", 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), "gfsrt", 21, S::npos);
     test(S("latkmisecnorjbfhqpdg"), "pfsocbhjtm", 21, S::npos);
     test(S("lecfratdjkhnsmqpoigb"), "tpflmdnoicjgkberhqsa", 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
     test(S(""), "pqlnkmbdjo", S::npos);
     test(S(""), "qkamfogpnljdcshbreti", S::npos);
     test(S("nhmko"), "", S::npos);
     test(S("lahfb"), "irkhs", 2);
     test(S("gmfhd"), "kantesmpgj", 0);
     test(S("odaft"), "oknlrstdpiqmjbaghcfe", 0);
     test(S("eolhfgpjqk"), "", S::npos);
     test(S("nbatdlmekr"), "bnrpe", 0);
     test(S("jdmciepkaq"), "jtdaefblso", 0);
     test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", 0);
     test(S("gprdcokbnjhlsfmtieqa"), "", S::npos);
     test(S("qjghlnftcaismkropdeb"), "bjaht", 1);
     test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 0);
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<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.ops/string_find.first.of/pointer_size_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos, n));
     assert(s.find_first_of(str, pos, n) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
     test(S(""), "kante", 0, 1, S::npos);
     test(S(""), "oknlr", 0, 2, S::npos);
     test(S(""), "pcdro", 0, 4, S::npos);
     test(S(""), "bnrpe", 0, 5, S::npos);
     test(S(""), "jtdaefblso", 0, 0, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("fthqm"), "dmasojntqleribkgfchp", 4, 20, 4);
     test(S("klopi"), "", 5, 0, S::npos);
     test(S("dajhn"), "psthd", 5, 0, S::npos);
     test(S("jbgno"), "rpmjd", 5, 1, S::npos);
     test(S("hkjae"), "dfsmk", 5, 2, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, S::npos);
     test(S("ktdor"), "kipnf", 5, 5, S::npos);
     test(S("ldprn"), "hmrnqdgifl", 5, 0, S::npos);
     test(S("egmjk"), "fsmjcdairn", 5, 1, S::npos);
     test(S("armql"), "pcdgltbrfj", 5, 5, S::npos);
     test(S("cdhjo"), "aekfctpirg", 5, 9, S::npos);
     test(S("jcons"), "ledihrsgpf", 5, 10, S::npos);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("gqtjsbdckh"), "otdma", 10, 2, S::npos);
     test(S("cfkqpjlegi"), "efhjg", 10, 4, S::npos);
     test(S("beanrfodgj"), "odpte", 10, 5, S::npos);
     test(S("adtkqpbjfi"), "bctdgfmolr", 10, 0, S::npos);
     test(S("iomkfthagj"), "oaklidrbqg", 10, 1, S::npos);
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, S::npos);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, S::npos);
     test(S("bmeqgcdorj"), "pjqonlebsf", 10, 10, S::npos);
     test(S("etqlcanmob"), "dshmnbtolcjepgaikfqr", 10, 0, S::npos);
     test(S("roqmkbdtia"), "iogfhpabtjkqlrnemcds", 10, 1, S::npos);
     test(S("kadsithljf"), "ngridfabjsecpqltkmoh", 10, 10, S::npos);
     test(S("sgtkpbfdmh"), "athmknplcgofrqejsdib", 10, 19, S::npos);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("focalnrpiqmdkstehbjg"), "apiblotgcd", 20, 1, S::npos);
     test(S("rhqdspkmebiflcotnjga"), "acfhdenops", 20, 5, S::npos);
     test(S("rahdtmsckfboqlpniegj"), "jopdeamcrk", 20, 9, S::npos);
     test(S("fbkeiopclstmdqranjhg"), "trqncbkgmh", 20, 10, S::npos);
     test(S("lifhpdgmbconstjeqark"), "tomglrkencbsfjqpihda", 20, 0, S::npos);
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, S::npos);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, S::npos);
     test(S("sirfgmjqhctndbklaepo"), "ohkmdpfqbsacrtjnlgei", 20, 19, S::npos);
     test(S("rlbdsiceaonqjtfpghkm"), "dlbrteoisgphmkncajfq", 20, 20, S::npos);
     test(S("ecgdanriptblhjfqskom"), "", 21, 0, S::npos);
     test(S("fdmiarlpgcskbhoteqjn"), "sjrlo", 21, 0, S::npos);
     test(S("rlbstjqopignecmfadkh"), "qjpor", 21, 1, S::npos);
     test(S("grjpqmbshektdolcafni"), "odhfn", 21, 2, S::npos);
     test(S("sakfcohtqnibprjmlged"), "qtfin", 21, 4, S::npos);
     test(S("mjtdglasihqpocebrfkn"), "hpqfo", 21, 5, S::npos);
     test(S("okaplfrntghqbmeicsdj"), "fabmertkos", 21, 0, S::npos);
     test(S("sahngemrtcjidqbklfpo"), "brqtgkmaej", 21, 1, S::npos);
     test(S("dlmsipcnekhbgoaftqjr"), "nfrdeihsgl", 21, 5, S::npos);
     test(S("ahegrmqnoiklpfsdbcjt"), "hlfrosekpi", 21, 9, S::npos);
     test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, S::npos);
     test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, S::npos);
     test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, S::npos);
     test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, S::npos);
     test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, S::npos);
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<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.ops/string_find.first.of/string_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
     assert(s.find_first_of(str, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
     assert(s.find_first_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
     test(S(""), S("pqlnkmbdjo"), 0, S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), S(""), 1, S::npos);
     test(S(""), S("bjaht"), 1, S::npos);
     test(S(""), S("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), S("lsckfnqgdahejiopbtmr"), 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), S(""), 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), S("gfsrt"), 21, S::npos);
     test(S("latkmisecnorjbfhqpdg"), S("pfsocbhjtm"), 21, S::npos);
     test(S("lecfratdjkhnsmqpoigb"), S("tpflmdnoicjgkberhqsa"), 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
     test(S(""), S("pqlnkmbdjo"), S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), S(""), S::npos);
     test(S("lahfb"), S("irkhs"), 2);
     test(S("gmfhd"), S("kantesmpgj"), 0);
     test(S("odaft"), S("oknlrstdpiqmjbaghcfe"), 0);
     test(S("eolhfgpjqk"), S(""), S::npos);
     test(S("nbatdlmekr"), S("bnrpe"), 0);
     test(S("jdmciepkaq"), S("jtdaefblso"), 0);
     test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), 0);
     test(S("gprdcokbnjhlsfmtieqa"), S(""), S::npos);
     test(S("qjghlnftcaismkropdeb"), S("bjaht"), 1);
     test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 0);
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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
+  { // LWG 2946
     std::string s = " !";
     assert(s.find_first_of({"abc", 1}) == std::string::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.ops/string_find.first.of/string_view_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(sv, pos));
     assert(s.find_first_of(sv, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(sv));
     assert(s.find_first_of(sv) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, S::npos);
     test(S(""), SV("laenf"), 0, S::npos);
     test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), SV(""), 1, S::npos);
     test(S(""), SV("bjaht"), 1, S::npos);
     test(S(""), SV("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, S::npos);
     test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, S::npos);
     test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, S::npos);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
     test(S(""), SV("pqlnkmbdjo"), S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), SV(""), S::npos);
     test(S("lahfb"), SV("irkhs"), 2);
     test(S("gmfhd"), SV("kantesmpgj"), 0);
     test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), 0);
     test(S("eolhfgpjqk"), SV(""), S::npos);
     test(S("nbatdlmekr"), SV("bnrpe"), 0);
     test(S("jdmciepkaq"), SV("jtdaefblso"), 0);
     test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), 0);
     test(S("gprdcokbnjhlsfmtieqa"), SV(""), S::npos);
     test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 1);
     test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 0);
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c, pos));
     assert(s.find_last_not_of(c, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c));
     assert(s.find_last_not_of(c) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 'i', 0, S::npos);
     test(S(""), 'i', 1, S::npos);
     test(S("kitcj"), 'i', 0, 0);
     test(S("qkamf"), 'i', 1, 1);
     test(S("nhmko"), 'i', 2, 2);
     test(S("tpsaf"), 'i', 4, 4);
     test(S("lahfb"), 'i', 5, 4);
bool test() {
     test(S("jtdaefblsokrmhpgcnqi"), 'i', 19, 18);
     test(S("hkbgspofltajcnedqmri"), 'i', 20, 18);
     test(S("oselktgbcapndfjihrmq"), 'i', 21, 19);
 
     test(S(""), 'i', S::npos);
     test(S("csope"), 'i', 4);
     test(S("gfsmthlkon"), 'i', 9);
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'i', 0, S::npos);
     test(S(""), 'i', 1, S::npos);
     test(S("kitcj"), 'i', 0, 0);
     test(S("qkamf"), 'i', 1, 1);
     test(S("nhmko"), 'i', 2, 2);
     test(S("tpsaf"), 'i', 4, 4);
     test(S("lahfb"), 'i', 5, 4);
#if TEST_STD_VER >= 11
     test(S("jtdaefblsokrmhpgcnqi"), 'i', 19, 18);
     test(S("hkbgspofltajcnedqmri"), 'i', 20, 18);
     test(S("oselktgbcapndfjihrmq"), 'i', 21, 19);
 
     test(S(""), 'i', S::npos);
     test(S("csope"), 'i', 4);
     test(S("gfsmthlkon"), 'i', 9);
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
-    }
 #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.ops/string_find.last.not.of/pointer_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
     assert(s.find_last_not_of(str, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str));
     assert(s.find_last_not_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
     test(S(""), "pqlnkmbdjo", 0, S::npos);
     test(S(""), "qkamfogpnljdcshbreti", 0, S::npos);
     test(S(""), "", 1, S::npos);
     test(S(""), "bjaht", 1, S::npos);
     test(S(""), "hjlcmgpket", 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), "lsckfnqgdahejiopbtmr", 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), "", 21, 19);
     test(S("binjagtfldkrspcomqeh"), "gfsrt", 21, 19);
     test(S("latkmisecnorjbfhqpdg"), "pfsocbhjtm", 21, 19);
     test(S("lecfratdjkhnsmqpoigb"), "tpflmdnoicjgkberhqsa", 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
     test(S(""), "pqlnkmbdjo", S::npos);
     test(S(""), "qkamfogpnljdcshbreti", S::npos);
     test(S("nhmko"), "", 4);
     test(S("lahfb"), "irkhs", 4);
     test(S("gmfhd"), "kantesmpgj", 4);
     test(S("odaft"), "oknlrstdpiqmjbaghcfe", S::npos);
     test(S("eolhfgpjqk"), "", 9);
     test(S("nbatdlmekr"), "bnrpe", 8);
     test(S("jdmciepkaq"), "jtdaefblso", 9);
     test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", S::npos);
     test(S("gprdcokbnjhlsfmtieqa"), "", 19);
     test(S("qjghlnftcaismkropdeb"), "bjaht", 18);
     test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 17);
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<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.ops/string_find.last.not.of/pointer_size_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos, n));
     assert(s.find_last_not_of(str, pos, n) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
     test(S(""), "kante", 0, 1, S::npos);
     test(S(""), "oknlr", 0, 2, S::npos);
     test(S(""), "pcdro", 0, 4, S::npos);
     test(S(""), "bnrpe", 0, 5, S::npos);
     test(S(""), "jtdaefblso", 0, 0, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("fthqm"), "dmasojntqleribkgfchp", 4, 20, S::npos);
     test(S("klopi"), "", 5, 0, 4);
     test(S("dajhn"), "psthd", 5, 0, 4);
     test(S("jbgno"), "rpmjd", 5, 1, 4);
     test(S("hkjae"), "dfsmk", 5, 2, 4);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, 4);
     test(S("ktdor"), "kipnf", 5, 5, 4);
     test(S("ldprn"), "hmrnqdgifl", 5, 0, 4);
     test(S("egmjk"), "fsmjcdairn", 5, 1, 4);
     test(S("armql"), "pcdgltbrfj", 5, 5, 3);
     test(S("cdhjo"), "aekfctpirg", 5, 9, 4);
     test(S("jcons"), "ledihrsgpf", 5, 10, 3);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("gqtjsbdckh"), "otdma", 10, 2, 9);
     test(S("cfkqpjlegi"), "efhjg", 10, 4, 9);
     test(S("beanrfodgj"), "odpte", 10, 5, 9);
     test(S("adtkqpbjfi"), "bctdgfmolr", 10, 0, 9);
     test(S("iomkfthagj"), "oaklidrbqg", 10, 1, 9);
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, 8);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, 9);
     test(S("bmeqgcdorj"), "pjqonlebsf", 10, 10, 8);
     test(S("etqlcanmob"), "dshmnbtolcjepgaikfqr", 10, 0, 9);
     test(S("roqmkbdtia"), "iogfhpabtjkqlrnemcds", 10, 1, 9);
     test(S("kadsithljf"), "ngridfabjsecpqltkmoh", 10, 10, 7);
     test(S("sgtkpbfdmh"), "athmknplcgofrqejsdib", 10, 19, 5);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("focalnrpiqmdkstehbjg"), "apiblotgcd", 20, 1, 19);
     test(S("rhqdspkmebiflcotnjga"), "acfhdenops", 20, 5, 18);
     test(S("rahdtmsckfboqlpniegj"), "jopdeamcrk", 20, 9, 18);
     test(S("fbkeiopclstmdqranjhg"), "trqncbkgmh", 20, 10, 17);
     test(S("lifhpdgmbconstjeqark"), "tomglrkencbsfjqpihda", 20, 0, 19);
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, 19);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, 19);
     test(S("sirfgmjqhctndbklaepo"), "ohkmdpfqbsacrtjnlgei", 20, 19, 1);
     test(S("rlbdsiceaonqjtfpghkm"), "dlbrteoisgphmkncajfq", 20, 20, S::npos);
     test(S("ecgdanriptblhjfqskom"), "", 21, 0, 19);
     test(S("fdmiarlpgcskbhoteqjn"), "sjrlo", 21, 0, 19);
     test(S("rlbstjqopignecmfadkh"), "qjpor", 21, 1, 19);
     test(S("grjpqmbshektdolcafni"), "odhfn", 21, 2, 19);
     test(S("sakfcohtqnibprjmlged"), "qtfin", 21, 4, 19);
     test(S("mjtdglasihqpocebrfkn"), "hpqfo", 21, 5, 19);
     test(S("okaplfrntghqbmeicsdj"), "fabmertkos", 21, 0, 19);
     test(S("sahngemrtcjidqbklfpo"), "brqtgkmaej", 21, 1, 19);
     test(S("dlmsipcnekhbgoaftqjr"), "nfrdeihsgl", 21, 5, 18);
     test(S("ahegrmqnoiklpfsdbcjt"), "hlfrosekpi", 21, 9, 19);
     test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, 19);
     test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, 19);
     test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, 19);
     test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, 19);
     test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, 7);
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<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.ops/string_find.last.not.of/string_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
     assert(s.find_last_not_of(str, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str));
     assert(s.find_last_not_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
     test(S(""), S("pqlnkmbdjo"), 0, S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), S(""), 1, S::npos);
     test(S(""), S("bjaht"), 1, S::npos);
     test(S(""), S("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), S("lsckfnqgdahejiopbtmr"), 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), S(""), 21, 19);
     test(S("binjagtfldkrspcomqeh"), S("gfsrt"), 21, 19);
     test(S("latkmisecnorjbfhqpdg"), S("pfsocbhjtm"), 21, 19);
     test(S("lecfratdjkhnsmqpoigb"), S("tpflmdnoicjgkberhqsa"), 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
     test(S(""), S("pqlnkmbdjo"), S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), S(""), 4);
     test(S("lahfb"), S("irkhs"), 4);
     test(S("gmfhd"), S("kantesmpgj"), 4);
     test(S("odaft"), S("oknlrstdpiqmjbaghcfe"), S::npos);
     test(S("eolhfgpjqk"), S(""), 9);
     test(S("nbatdlmekr"), S("bnrpe"), 8);
     test(S("jdmciepkaq"), S("jtdaefblso"), 9);
     test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), S::npos);
     test(S("gprdcokbnjhlsfmtieqa"), S(""), 19);
     test(S("qjghlnftcaismkropdeb"), S("bjaht"), 18);
     test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 17);
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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
+  { // LWG 2946
     std::string s = " !";
     assert(s.find_last_not_of({"abc", 1}) == s.size() - 1);
-    }
 #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.ops/string_find.last.not.of/string_view_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(sv, pos));
     assert(s.find_last_not_of(sv, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(sv));
     assert(s.find_last_not_of(sv) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, S::npos);
     test(S(""), SV("laenf"), 0, S::npos);
     test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), SV(""), 1, S::npos);
     test(S(""), SV("bjaht"), 1, S::npos);
     test(S(""), SV("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, 19);
     test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, 19);
     test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, 19);
     test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, S::npos);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
     test(S(""), SV("pqlnkmbdjo"), S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), SV(""), 4);
     test(S("lahfb"), SV("irkhs"), 4);
     test(S("gmfhd"), SV("kantesmpgj"), 4);
     test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), S::npos);
     test(S("eolhfgpjqk"), SV(""), 9);
     test(S("nbatdlmekr"), SV("bnrpe"), 8);
     test(S("jdmciepkaq"), SV("jtdaefblso"), 9);
     test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), S::npos);
     test(S("gprdcokbnjhlsfmtieqa"), SV(""), 19);
     test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 18);
     test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 17);
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
 //     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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c, pos));
     assert(s.find_last_of(c, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c));
     assert(s.find_last_of(c) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 'm', 0, S::npos);
     test(S(""), 'm', 1, S::npos);
     test(S("kitcj"), 'm', 0, S::npos);
     test(S("qkamf"), 'm', 1, S::npos);
     test(S("nhmko"), 'm', 2, 2);
     test(S("tpsaf"), 'm', 4, S::npos);
     test(S("lahfb"), 'm', 5, S::npos);
bool test() {
     test(S("jtdaefblsokrmhpgcnqi"), 'm', 19, 12);
     test(S("hkbgspofltajcnedqmri"), 'm', 20, 17);
     test(S("oselktgbcapndfjihrmq"), 'm', 21, 18);
 
     test(S(""), 'm', S::npos);
     test(S("csope"), 'm', S::npos);
     test(S("gfsmthlkon"), 'm', 3);
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'm', 0, S::npos);
     test(S(""), 'm', 1, S::npos);
     test(S("kitcj"), 'm', 0, S::npos);
     test(S("qkamf"), 'm', 1, S::npos);
     test(S("nhmko"), 'm', 2, 2);
     test(S("tpsaf"), 'm', 4, S::npos);
     test(S("lahfb"), 'm', 5, S::npos);
#if TEST_STD_VER >= 11
     test(S("jtdaefblsokrmhpgcnqi"), 'm', 19, 12);
     test(S("hkbgspofltajcnedqmri"), 'm', 20, 17);
     test(S("oselktgbcapndfjihrmq"), 'm', 21, 18);
 
     test(S(""), 'm', S::npos);
     test(S("csope"), 'm', S::npos);
     test(S("gfsmthlkon"), 'm', 3);
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
-    }
 #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.ops/string_find.last.of/pointer_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
     assert(s.find_last_of(str, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
     assert(s.find_last_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
     test(S(""), "pqlnkmbdjo", 0, S::npos);
     test(S(""), "qkamfogpnljdcshbreti", 0, S::npos);
     test(S(""), "", 1, S::npos);
     test(S(""), "bjaht", 1, S::npos);
     test(S(""), "hjlcmgpket", 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), "lsckfnqgdahejiopbtmr", 20, 19);
     test(S("liatsqdoegkmfcnbhrpj"), "", 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), "gfsrt", 21, 12);
     test(S("latkmisecnorjbfhqpdg"), "pfsocbhjtm", 21, 17);
     test(S("lecfratdjkhnsmqpoigb"), "tpflmdnoicjgkberhqsa", 21, 19);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
     test(S(""), "pqlnkmbdjo", S::npos);
     test(S(""), "qkamfogpnljdcshbreti", S::npos);
     test(S("nhmko"), "", S::npos);
     test(S("lahfb"), "irkhs", 2);
     test(S("gmfhd"), "kantesmpgj", 1);
     test(S("odaft"), "oknlrstdpiqmjbaghcfe", 4);
     test(S("eolhfgpjqk"), "", S::npos);
     test(S("nbatdlmekr"), "bnrpe", 9);
     test(S("jdmciepkaq"), "jtdaefblso", 8);
     test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", 9);
     test(S("gprdcokbnjhlsfmtieqa"), "", S::npos);
     test(S("qjghlnftcaismkropdeb"), "bjaht", 19);
     test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 19);
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<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.ops/string_find.last.of/pointer_size_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos, n));
     assert(s.find_last_of(str, pos, n) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
     test(S(""), "kante", 0, 1, S::npos);
     test(S(""), "oknlr", 0, 2, S::npos);
     test(S(""), "pcdro", 0, 4, S::npos);
     test(S(""), "bnrpe", 0, 5, S::npos);
     test(S(""), "jtdaefblso", 0, 0, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("fthqm"), "dmasojntqleribkgfchp", 4, 20, 4);
     test(S("klopi"), "", 5, 0, S::npos);
     test(S("dajhn"), "psthd", 5, 0, S::npos);
     test(S("jbgno"), "rpmjd", 5, 1, S::npos);
     test(S("hkjae"), "dfsmk", 5, 2, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, 3);
     test(S("ktdor"), "kipnf", 5, 5, 0);
     test(S("ldprn"), "hmrnqdgifl", 5, 0, S::npos);
     test(S("egmjk"), "fsmjcdairn", 5, 1, S::npos);
     test(S("armql"), "pcdgltbrfj", 5, 5, 4);
     test(S("cdhjo"), "aekfctpirg", 5, 9, 0);
     test(S("jcons"), "ledihrsgpf", 5, 10, 4);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("gqtjsbdckh"), "otdma", 10, 2, 2);
     test(S("cfkqpjlegi"), "efhjg", 10, 4, 7);
     test(S("beanrfodgj"), "odpte", 10, 5, 7);
     test(S("adtkqpbjfi"), "bctdgfmolr", 10, 0, S::npos);
     test(S("iomkfthagj"), "oaklidrbqg", 10, 1, 1);
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, 9);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, 8);
     test(S("bmeqgcdorj"), "pjqonlebsf", 10, 10, 9);
     test(S("etqlcanmob"), "dshmnbtolcjepgaikfqr", 10, 0, S::npos);
     test(S("roqmkbdtia"), "iogfhpabtjkqlrnemcds", 10, 1, 8);
     test(S("kadsithljf"), "ngridfabjsecpqltkmoh", 10, 10, 9);
     test(S("sgtkpbfdmh"), "athmknplcgofrqejsdib", 10, 19, 9);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("focalnrpiqmdkstehbjg"), "apiblotgcd", 20, 1, 3);
     test(S("rhqdspkmebiflcotnjga"), "acfhdenops", 20, 5, 19);
     test(S("rahdtmsckfboqlpniegj"), "jopdeamcrk", 20, 9, 19);
     test(S("fbkeiopclstmdqranjhg"), "trqncbkgmh", 20, 10, 19);
     test(S("lifhpdgmbconstjeqark"), "tomglrkencbsfjqpihda", 20, 0, S::npos);
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, 4);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, 17);
     test(S("sirfgmjqhctndbklaepo"), "ohkmdpfqbsacrtjnlgei", 20, 19, 19);
     test(S("rlbdsiceaonqjtfpghkm"), "dlbrteoisgphmkncajfq", 20, 20, 19);
     test(S("ecgdanriptblhjfqskom"), "", 21, 0, S::npos);
     test(S("fdmiarlpgcskbhoteqjn"), "sjrlo", 21, 0, S::npos);
     test(S("rlbstjqopignecmfadkh"), "qjpor", 21, 1, 6);
     test(S("grjpqmbshektdolcafni"), "odhfn", 21, 2, 13);
     test(S("sakfcohtqnibprjmlged"), "qtfin", 21, 4, 10);
     test(S("mjtdglasihqpocebrfkn"), "hpqfo", 21, 5, 17);
     test(S("okaplfrntghqbmeicsdj"), "fabmertkos", 21, 0, S::npos);
     test(S("sahngemrtcjidqbklfpo"), "brqtgkmaej", 21, 1, 14);
     test(S("dlmsipcnekhbgoaftqjr"), "nfrdeihsgl", 21, 5, 19);
     test(S("ahegrmqnoiklpfsdbcjt"), "hlfrosekpi", 21, 9, 14);
     test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, 16);
     test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, S::npos);
     test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, 17);
     test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, 17);
     test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, 19);
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<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.ops/string_find.last.of/string_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
     assert(s.find_last_of(str, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
     assert(s.find_last_of(str) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
     test(S(""), S("pqlnkmbdjo"), 0, S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), S(""), 1, S::npos);
     test(S(""), S("bjaht"), 1, S::npos);
     test(S(""), S("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), S("lsckfnqgdahejiopbtmr"), 20, 19);
     test(S("liatsqdoegkmfcnbhrpj"), S(""), 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), S("gfsrt"), 21, 12);
     test(S("latkmisecnorjbfhqpdg"), S("pfsocbhjtm"), 21, 17);
     test(S("lecfratdjkhnsmqpoigb"), S("tpflmdnoicjgkberhqsa"), 21, 19);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
     test(S(""), S("pqlnkmbdjo"), S::npos);
     test(S(""), S("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), S(""), S::npos);
     test(S("lahfb"), S("irkhs"), 2);
     test(S("gmfhd"), S("kantesmpgj"), 1);
     test(S("odaft"), S("oknlrstdpiqmjbaghcfe"), 4);
     test(S("eolhfgpjqk"), S(""), S::npos);
     test(S("nbatdlmekr"), S("bnrpe"), 9);
     test(S("jdmciepkaq"), S("jtdaefblso"), 8);
     test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), 9);
     test(S("gprdcokbnjhlsfmtieqa"), S(""), S::npos);
     test(S("qjghlnftcaismkropdeb"), S("bjaht"), 19);
     test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 19);
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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
+  { // LWG 2946
     std::string s = " !";
     assert(s.find_last_of({"abc", 1}) == std::string::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.ops/string_find.last.of/string_view_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(sv, pos));
     assert(s.find_last_of(sv, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(sv));
     assert(s.find_last_of(sv) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, S::npos);
     test(S(""), SV("laenf"), 0, S::npos);
     test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), SV(""), 1, S::npos);
     test(S(""), SV("bjaht"), 1, S::npos);
     test(S(""), SV("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, 19);
     test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, S::npos);
     test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, 12);
     test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, 17);
     test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, 19);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
     test(S(""), SV("pqlnkmbdjo"), S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), SV(""), S::npos);
     test(S("lahfb"), SV("irkhs"), 2);
     test(S("gmfhd"), SV("kantesmpgj"), 1);
     test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), 4);
     test(S("eolhfgpjqk"), SV(""), S::npos);
     test(S("nbatdlmekr"), SV("bnrpe"), 9);
     test(S("jdmciepkaq"), SV("jtdaefblso"), 8);
     test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), 9);
     test(S("gprdcokbnjhlsfmtieqa"), SV(""), S::npos);
     test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 19);
     test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 19);
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(c, pos));
     assert(s.find(c, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x + 1 <= s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(c));
     assert(s.find(c) == x);
     if (x != S::npos)
         assert(0 <= x && x + 1 <= s.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 'c', 0, S::npos);
     test(S(""), 'c', 1, S::npos);
     test(S("abcde"), 'c', 0, 2);
     test(S("abcde"), 'c', 1, 2);
     test(S("abcde"), 'c', 2, 2);
     test(S("abcde"), 'c', 4, S::npos);
     test(S("abcde"), 'c', 5, S::npos);
bool test() {
     test(S("abcdeabcdeabcdeabcde"), 'c', 19, S::npos);
     test(S("abcdeabcdeabcdeabcde"), 'c', 20, S::npos);
     test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos);
 
     test(S(""), 'c', S::npos);
     test(S("abcde"), 'c', 2);
     test(S("abcdeabcde"), 'c', 2);
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'c', 0, S::npos);
     test(S(""), 'c', 1, S::npos);
     test(S("abcde"), 'c', 0, 2);
     test(S("abcde"), 'c', 1, 2);
     test(S("abcde"), 'c', 2, 2);
     test(S("abcde"), 'c', 4, S::npos);
     test(S("abcde"), 'c', 5, S::npos);
#if TEST_STD_VER >= 11
     test(S("abcdeabcdeabcdeabcde"), 'c', 19, S::npos);
     test(S("abcdeabcdeabcdeabcde"), 'c', 20, S::npos);
     test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos);
 
     test(S(""), 'c', S::npos);
     test(S("abcde"), 'c', 2);
     test(S("abcdeabcde"), 'c', 2);
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
-    }
 #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.ops/string_find/pointer_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
     assert(s.find(str, pos) == x);
     if (x != S::npos)
     {
         typename S::size_type n = S::traits_type::length(str);
         assert(pos <= x && x + n <= s.size());
     }
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str));
     assert(s.find(str) == x);
     if (x != S::npos)
     {
         typename S::size_type n = S::traits_type::length(str);
         assert(0 <= x && x + n <= s.size());
     }
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0);
     test(S(""), "abcde", 0, S::npos);
     test(S(""), "abcdeabcde", 0, S::npos);
     test(S(""), "abcdeabcdeabcdeabcde", 0, S::npos);
     test(S(""), "", 1, S::npos);
     test(S(""), "abcde", 1, S::npos);
     test(S(""), "abcdeabcde", 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "", 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", 0);
     test(S(""), "abcde", S::npos);
     test(S(""), "abcdeabcde", S::npos);
     test(S(""), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcde"), "", 0);
     test(S("abcde"), "abcde", 0);
     test(S("abcde"), "abcdeabcde", S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcdeabcde"), "", 0);
     test(S("abcdeabcde"), "abcde", 0);
     test(S("abcdeabcde"), "abcdeabcde", 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcdeabcdeabcdeabcde"), "", 0);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<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.ops/string_find/pointer_size_size.pass.cpp

 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos, n));
     assert(s.find(str, pos, n) == x);
     if (x != S::npos)
         assert(pos <= x && x + n <= s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, 0);
     test(S(""), "abcde", 0, 0, 0);
     test(S(""), "abcde", 0, 1, S::npos);
     test(S(""), "abcde", 0, 2, S::npos);
     test(S(""), "abcde", 0, 4, S::npos);
     test(S(""), "abcde", 0, 5, S::npos);
     test(S(""), "abcdeabcde", 0, 0, 0);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), "abcdeabcdeabcdeabcde", 4, 20, S::npos);
     test(S("abcde"), "", 5, 0, 5);
     test(S("abcde"), "abcde", 5, 0, 5);
     test(S("abcde"), "abcde", 5, 1, S::npos);
     test(S("abcde"), "abcde", 5, 2, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), "abcde", 5, 4, S::npos);
     test(S("abcde"), "abcde", 5, 5, S::npos);
     test(S("abcde"), "abcdeabcde", 5, 0, 5);
     test(S("abcde"), "abcdeabcde", 5, 1, S::npos);
     test(S("abcde"), "abcdeabcde", 5, 5, S::npos);
     test(S("abcde"), "abcdeabcde", 5, 9, S::npos);
     test(S("abcde"), "abcdeabcde", 5, 10, S::npos);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdeabcde"), "abcde", 10, 2, S::npos);
     test(S("abcdeabcde"), "abcde", 10, 4, S::npos);
     test(S("abcdeabcde"), "abcde", 10, 5, S::npos);
     test(S("abcdeabcde"), "abcdeabcde", 10, 0, 10);
     test(S("abcdeabcde"), "abcdeabcde", 10, 1, S::npos);
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdeabcde"), "abcdeabcde", 10, 5, S::npos);
     test(S("abcdeabcde"), "abcdeabcde", 10, 9, S::npos);
     test(S("abcdeabcde"), "abcdeabcde", 10, 10, S::npos);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 0, 10);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 1, S::npos);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 10, S::npos);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 19, S::npos);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 1, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 5, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 9, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 10, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 0, 20);
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 1, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 10, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 19, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 20, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "", 21, 0, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 0, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 1, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 2, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 4, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 5, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 0, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 1, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 5, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 9, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 10, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 0, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 1, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 10, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 19, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<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.ops/string_find/string_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
     assert(s.find(str, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x + str.size() <= s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str));
     assert(s.find(str) == x);
     if (x != S::npos)
         assert(0 <= x && x + str.size() <= s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, 0);
     test(S(""), S("abcde"), 0, S::npos);
     test(S(""), S("abcdeabcde"), 0, S::npos);
     test(S(""), S("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S(""), S(""), 1, S::npos);
     test(S(""), S("abcde"), 1, S::npos);
     test(S(""), S("abcdeabcde"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 20, S::npos);
     test(S("abcdeabcdeabcdeabcde"), S(""), 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 21, S::npos);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), S::npos);
     test(S(""), S("abcdeabcde"), S::npos);
     test(S(""), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcde"), S(""), 0);
     test(S("abcde"), S("abcde"), 0);
     test(S("abcde"), S("abcdeabcde"), S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcde"), S(""), 0);
     test(S("abcdeabcde"), S("abcde"), 0);
     test(S("abcdeabcde"), S("abcdeabcde"), 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcdeabcdeabcde"), S(""), 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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
+  { // LWG 2946
     std::string s = " !";
     assert(s.find({"abc", 1}) == std::string::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.ops/string_find/string_view_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(sv, pos));
     assert(s.find(sv, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x + sv.size() <= s.size());
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(sv));
     assert(s.find(sv) == x);
     if (x != S::npos)
         assert(0 <= x && x + sv.size() <= s.size());
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, 0);
     test(S(""), SV("abcde"), 0, S::npos);
     test(S(""), SV("abcdeabcde"), 0, S::npos);
     test(S(""), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S(""), SV(""), 1, S::npos);
     test(S(""), SV("abcde"), 1, S::npos);
     test(S(""), SV("abcdeabcde"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 20, S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 21, S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 21, S::npos);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), 0);
     test(S(""), SV("abcde"), S::npos);
     test(S(""), SV("abcdeabcde"), S::npos);
     test(S(""), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcde"), SV(""), 0);
     test(S("abcde"), SV("abcde"), 0);
     test(S("abcde"), SV("abcdeabcde"), S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcde"), SV(""), 0);
     test(S("abcdeabcde"), SV("abcde"), 0);
     test(S("abcdeabcde"), SV("abcdeabcde"), 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(c, pos));
     assert(s.rfind(c, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x + 1 <= s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(c));
     assert(s.rfind(c) == x);
     if (x != S::npos)
         assert(x + 1 <= s.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 'b', 0, S::npos);
     test(S(""), 'b', 1, S::npos);
     test(S("abcde"), 'b', 0, S::npos);
     test(S("abcde"), 'b', 1, 1);
     test(S("abcde"), 'b', 2, 1);
     test(S("abcde"), 'b', 4, 1);
     test(S("abcde"), 'b', 5, 1);
bool test() {
     test(S("abcdeabcdeabcdeabcde"), 'b', 19, 16);
     test(S("abcdeabcdeabcdeabcde"), 'b', 20, 16);
     test(S("abcdeabcdeabcdeabcde"), 'b', 21, 16);
 
     test(S(""), 'b', S::npos);
     test(S("abcde"), 'b', 1);
     test(S("abcdeabcde"), 'b', 6);
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 'b', 0, S::npos);
     test(S(""), 'b', 1, S::npos);
     test(S("abcde"), 'b', 0, S::npos);
     test(S("abcde"), 'b', 1, 1);
     test(S("abcde"), 'b', 2, 1);
     test(S("abcde"), 'b', 4, 1);
     test(S("abcde"), 'b', 5, 1);
#if TEST_STD_VER >= 11
     test(S("abcdeabcdeabcdeabcde"), 'b', 19, 16);
     test(S("abcdeabcdeabcdeabcde"), 'b', 20, 16);
     test(S("abcdeabcdeabcdeabcde"), 'b', 21, 16);
 
     test(S(""), 'b', S::npos);
     test(S("abcde"), 'b', 1);
     test(S("abcdeabcde"), 'b', 6);
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
-    }
 #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.ops/string_rfind/pointer_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
     assert(s.rfind(str, pos) == x);
     if (x != S::npos)
     {
         typename S::size_type n = S::traits_type::length(str);
         assert(x <= pos && x + n <= s.size());
     }
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
     assert(s.rfind(str) == x);
     if (x != S::npos)
     {
         typename S::size_type pos = s.size();
         typename S::size_type n = S::traits_type::length(str);
         assert(x <= pos && x + n <= s.size());
     }
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0);
     test(S(""), "abcde", 0, S::npos);
     test(S(""), "abcdeabcde", 0, S::npos);
     test(S(""), "abcdeabcdeabcdeabcde", 0, S::npos);
     test(S(""), "", 1, 0);
     test(S(""), "abcde", 1, S::npos);
     test(S(""), "abcdeabcde", 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 0);
     test(S("abcdeabcdeabcdeabcde"), "", 21, 20);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 0);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", 0);
     test(S(""), "abcde", S::npos);
     test(S(""), "abcdeabcde", S::npos);
     test(S(""), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcde"), "", 5);
     test(S("abcde"), "abcde", 0);
     test(S("abcde"), "abcdeabcde", S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcdeabcde"), "", 10);
     test(S("abcdeabcde"), "abcde", 5);
     test(S("abcdeabcde"), "abcdeabcde", 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcdeabcdeabcdeabcde"), "", 20);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<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.ops/string_rfind/pointer_size_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
       typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos, n));
     assert(s.rfind(str, pos, n) == x);
     if (x != S::npos)
         assert(x <= pos && x + n <= s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, 0);
     test(S(""), "abcde", 0, 0, 0);
     test(S(""), "abcde", 0, 1, S::npos);
     test(S(""), "abcde", 0, 2, S::npos);
     test(S(""), "abcde", 0, 4, S::npos);
     test(S(""), "abcde", 0, 5, S::npos);
     test(S(""), "abcdeabcde", 0, 0, 0);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), "abcdeabcdeabcdeabcde", 4, 20, S::npos);
     test(S("abcde"), "", 5, 0, 5);
     test(S("abcde"), "abcde", 5, 0, 5);
     test(S("abcde"), "abcde", 5, 1, 0);
     test(S("abcde"), "abcde", 5, 2, 0);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), "abcde", 5, 4, 0);
     test(S("abcde"), "abcde", 5, 5, 0);
     test(S("abcde"), "abcdeabcde", 5, 0, 5);
     test(S("abcde"), "abcdeabcde", 5, 1, 0);
     test(S("abcde"), "abcdeabcde", 5, 5, 0);
     test(S("abcde"), "abcdeabcde", 5, 9, S::npos);
     test(S("abcde"), "abcdeabcde", 5, 10, S::npos);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdeabcde"), "abcde", 10, 2, 5);
     test(S("abcdeabcde"), "abcde", 10, 4, 5);
     test(S("abcdeabcde"), "abcde", 10, 5, 5);
     test(S("abcdeabcde"), "abcdeabcde", 10, 0, 10);
     test(S("abcdeabcde"), "abcdeabcde", 10, 1, 5);
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdeabcde"), "abcdeabcde", 10, 5, 5);
     test(S("abcdeabcde"), "abcdeabcde", 10, 9, 0);
     test(S("abcdeabcde"), "abcdeabcde", 10, 10, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 0, 10);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 1, 5);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 10, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, 19, S::npos);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 1, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 5, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 9, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 10, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 0, 20);
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 1, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 10, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 19, 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 20, 0);
     test(S("abcdeabcdeabcdeabcde"), "", 21, 0, 20);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 0, 20);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 1, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 2, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 4, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 5, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 0, 20);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 1, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 5, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 9, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 10, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 0, 20);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 1, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 10, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 19, 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<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.ops/string_rfind/string_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
     assert(s.rfind(str, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x + str.size() <= s.size());
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
     assert(s.rfind(str) == x);
     if (x != S::npos)
         assert(0 <= x && x + str.size() <= s.size());
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, 0);
     test(S(""), S("abcde"), 0, S::npos);
     test(S(""), S("abcdeabcde"), 0, S::npos);
     test(S(""), S("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S(""), S(""), 1, 0);
     test(S(""), S("abcde"), 1, S::npos);
     test(S(""), S("abcdeabcde"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 20, 0);
     test(S("abcdeabcdeabcdeabcde"), S(""), 21, 20);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 21, 15);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 21, 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 21, 0);
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), S::npos);
     test(S(""), S("abcdeabcde"), S::npos);
     test(S(""), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcde"), S(""), 5);
     test(S("abcde"), S("abcde"), 0);
     test(S("abcde"), S("abcdeabcde"), S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcde"), S(""), 10);
     test(S("abcdeabcde"), S("abcde"), 5);
     test(S("abcdeabcde"), S("abcdeabcde"), 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcdeabcdeabcde"), S(""), 20);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 15);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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
+  { // LWG 2946
     std::string s = " !";
     assert(s.rfind({"abc", 1}) == std::string::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.ops/string_rfind/string_view_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv, pos));
     assert(s.rfind(sv, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x + sv.size() <= s.size());
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv));
     assert(s.rfind(sv) == x);
     if (x != S::npos)
         assert(0 <= x && x + sv.size() <= s.size());
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, 0);
     test(S(""), SV("abcde"), 0, S::npos);
     test(S(""), SV("abcdeabcde"), 0, S::npos);
     test(S(""), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S(""), SV(""), 1, 0);
     test(S(""), SV("abcde"), 1, S::npos);
     test(S(""), SV("abcdeabcde"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 20, 0);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 21, 20);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 21, 15);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 21, 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 21, 0);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), 0);
     test(S(""), SV("abcde"), S::npos);
     test(S(""), SV("abcdeabcde"), S::npos);
     test(S(""), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcde"), SV(""), 5);
     test(S("abcde"), SV("abcde"), 0);
     test(S("abcde"), SV("abcdeabcde"), S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcde"), SV(""), 10);
     test(S("abcdeabcde"), SV("abcde"), 5);
     test(S("abcdeabcde"), SV("abcdeabcde"), 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 20);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 15);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     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 true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp

 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n)
 {
     if (pos <= s.size())
     {
         S str = s.substr(pos, n);
         LIBCPP_ASSERT(str.__invariants());
         assert(pos <= s.size());
         typename S::size_type rlen = std::min(n, s.size() - pos);
else
         catch (std::out_of_range&)
         {
             assert(pos > s.size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef std::string S;
     test(S(""), 0, 0);
     test(S(""), 1, 0);
     test(S("pniot"), 0, 0);
     test(S("htaob"), 0, 1);
     test(S("fodgq"), 0, 2);
     test(S("hpqia"), 0, 4);
#if TEST_STD_VER >= 11
     test(S("lmofqdhpkibagnrcjste"), 10, 10);
     test(S("lgjqketopbfahrmnsicd"), 19, 0);
     test(S("ktsrmnqagdecfhijpobl"), 19, 1);
     test(S("lsaijeqhtrbgcdmpfkno"), 20, 0);
     test(S("dplqartnfgejichmoskb"), 21, 0);
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }