[libc++] Prepare string.nonmembers for constexpr

libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.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(S s1, S s2)
 {
     S s1_ = s1;
     S s2_ = s2;
     swap(s1, s2);
     LIBCPP_ASSERT(s1.__invariants());
     LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s2_);
     assert(s2 == s1_);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""));
     test(S(""), S("12345"));
     test(S(""), S("1234567890"));
     test(S(""), S("12345678901234567890"));
     test(S("abcde"), S(""));
     test(S("abcde"), S("12345"));
     test(S("abcde"), S("1234567890"));
     test(S("abcde"), S("12345678901234567890"));
     test(S("abcdefghij"), S(""));
     test(S("abcdefghij"), S("12345"));
     test(S("abcdefghij"), S("1234567890"));
     test(S("abcdefghij"), S("12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), S(""));
     test(S("abcdefghijklmnopqrst"), S("12345"));
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""));
     test(S(""), S("12345"));
     test(S(""), S("1234567890"));
     test(S(""), S("12345678901234567890"));
     test(S("abcde"), S(""));
     test(S("abcde"), S("12345"));
     test(S("abcde"), S("1234567890"));
     test(S("abcde"), S("12345678901234567890"));
     test(S("abcdefghij"), S(""));
     test(S("abcdefghij"), S("12345"));
     test(S("abcdefghij"), S("1234567890"));
     test(S("abcdefghij"), S("12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), S(""));
     test(S("abcdefghijklmnopqrst"), S("12345"));
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
-    }
 #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.nonmembers/string_op!=/pointer_string.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test("", S(""), false);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);
     test("abcdefghij", S(""), true);
     test("abcdefghij", S("abcde"), true);
     test("abcdefghij", S("abcdefghij"), false);
     test("abcdefghij", S("abcdefghijklmnopqrst"), true);
     test("abcdefghijklmnopqrst", S(""), true);
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);
     test("abcdefghij", S(""), true);
     test("abcdefghij", S("abcde"), true);
     test("abcdefghij", S("abcdefghij"), false);
     test("abcdefghij", S("abcdefghijklmnopqrst"), true);
     test("abcdefghijklmnopqrst", S(""), true);
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_op!=/string_pointer.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& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), "", false);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghij"), "", true);
     test(S("abcdefghij"), "abcde", true);
     test(S("abcdefghij"), "abcdefghij", false);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghijklmnopqrst"), "", true);
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghij"), "", true);
     test(S("abcdefghij"), "abcde", true);
     test(S("abcdefghij"), "abcdefghij", false);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghijklmnopqrst"), "", true);
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-    }
 #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.nonmembers/string_op!=/string_string.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& lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), S(""), true);
     test(S("abcdefghij"), S("abcde"), true);
     test(S("abcdefghij"), S("abcdefghij"), false);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), S(""), true);
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), S(""), true);
     test(S("abcdefghij"), S("abcde"), true);
     test(S("abcdefghij"), S("abcdefghij"), false);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), S(""), true);
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_op!=/string_string_view.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& lhs, SV rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), SV(""), true);
     test(S("abcdefghij"), SV("abcde"), true);
     test(S("abcdefghij"), SV("abcdefghij"), false);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), SV(""), true);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), SV(""), true);
     test(S("abcdefghij"), SV("abcde"), true);
     test(S("abcdefghij"), SV("abcdefghij"), false);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), SV(""), true);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_op!=/string_view_string.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(SV lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghij"), S(""), true);
     test(SV("abcdefghij"), S("abcde"), true);
     test(SV("abcdefghij"), S("abcdefghij"), false);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghijklmnopqrst"), S(""), true);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghij"), S(""), true);
     test(SV("abcdefghij"), S("abcde"), true);
     test(SV("abcdefghij"), S("abcdefghij"), false);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghijklmnopqrst"), S(""), true);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_op+/char_string.pass.cpp

 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void test0(typename S::value_type lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(typename S::value_type lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(typename S::value_type lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(typename S::value_type lhs, S&& rhs, const S& x) {
   assert(lhs + move(rhs) == x);
 }
 #endif
 
-int main(int, char**) {
+bool test() {
   {
     typedef std::string S;
     test0('a', S(""), S("a"));
     test0('a', S("12345"), S("a12345"));
     test0('a', S("1234567890"), S("a1234567890"));
     test0('a', S("12345678901234567890"), S("a12345678901234567890"));
   }
 #if TEST_STD_VER >= 11
#if TEST_STD_VER >= 11
 
     test1('a', S(""), S("a"));
     test1('a', S("12345"), S("a12345"));
     test1('a', S("1234567890"), S("a1234567890"));
     test1('a', S("12345678901234567890"), S("a12345678901234567890"));
   }
 #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.nonmembers/string_op+/pointer_string.pass.cpp

 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void test0(const typename S::value_type* lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const typename S::value_type* lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(const typename S::value_type* lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(const typename S::value_type* lhs, S&& rhs, const S& x) {
   assert(lhs + move(rhs) == x);
 }
 #endif
 
-int main(int, char**) {
+bool test() {
   {
     typedef std::string S;
     test0("", S(""), S(""));
     test0("", S("12345"), S("12345"));
     test0("", S("1234567890"), S("1234567890"));
     test0("", S("12345678901234567890"), S("12345678901234567890"));
     test0("abcde", S(""), S("abcde"));
     test0("abcde", S("12345"), S("abcde12345"));
#if TEST_STD_VER >= 11
     test1("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
     test1("abcdefghijklmnopqrst", S("1234567890"),
           S("abcdefghijklmnopqrst1234567890"));
     test1("abcdefghijklmnopqrst", S("12345678901234567890"),
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #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.nonmembers/string_op+/string_char.pass.cpp

 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void test0(const S& lhs, typename S::value_type rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const S& lhs, typename S::value_type rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(S&& lhs, typename S::value_type rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(S&& lhs, typename S::value_type rhs, const S& x) {
   assert(move(lhs) + rhs == x);
 }
 #endif
 
-int main(int, char**) {
+bool test() {
   {
     typedef std::string S;
     test0(S(""), '1', S("1"));
     test0(S("abcde"), '1', S("abcde1"));
     test0(S("abcdefghij"), '1', S("abcdefghij1"));
     test0(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
   }
 #if TEST_STD_VER >= 11
#if TEST_STD_VER >= 11
 
     test1(S(""), '1', S("1"));
     test1(S("abcde"), '1', S("abcde1"));
     test1(S("abcdefghij"), '1', S("abcdefghij1"));
     test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
   }
 #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.nonmembers/string_op+/string_pointer.pass.cpp

 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void test0(const S& lhs, const typename S::value_type* rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const typename S::value_type* rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
   assert(move(lhs) + rhs == x);
 }
 #endif
 
-int main(int, char**) {
+bool test() {
   {
     typedef std::string S;
     test0(S(""), "", S(""));
     test0(S(""), "12345", S("12345"));
     test0(S(""), "1234567890", S("1234567890"));
     test0(S(""), "12345678901234567890", S("12345678901234567890"));
     test0(S("abcde"), "", S("abcde"));
     test0(S("abcde"), "12345", S("abcde12345"));
#if TEST_STD_VER >= 11
     test1(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
     test1(S("abcdefghijklmnopqrst"), "1234567890",
           S("abcdefghijklmnopqrst1234567890"));
     test1(S("abcdefghijklmnopqrst"), "12345678901234567890",
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #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.nonmembers/string_op+/string_string.pass.cpp

 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void test0(const S& lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(S&& lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const S& rhs, const S& x) {
   assert(move(lhs) + rhs == x);
 }
 
 template <class S>
-void test2(const S& lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test2(const S& lhs, S&& rhs, const S& x) {
   assert(lhs + move(rhs) == x);
 }
 
 template <class S>
-void test3(S&& lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test3(S&& lhs, S&& rhs, const S& x) {
   assert(move(lhs) + move(rhs) == x);
 }
-
 #endif
 
-int main(int, char**) {
+bool test() {
   {
     typedef std::string S;
     test0(S(""), S(""), S(""));
     test0(S(""), S("12345"), S("12345"));
     test0(S(""), S("1234567890"), S("1234567890"));
     test0(S(""), S("12345678901234567890"), S("12345678901234567890"));
     test0(S("abcde"), S(""), S("abcde"));
     test0(S("abcde"), S("12345"), S("abcde12345"));
test3(S("abcdefghijklmnopqrst"), S("12345"),
           S("abcdefghijklmnopqrst12345"));
     test3(S("abcdefghijklmnopqrst"), S("1234567890"),
           S("abcdefghijklmnopqrst1234567890"));
     test3(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #endif // TEST_STD_VER >= 11
 
+  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.nonmembers/string_operator==/pointer_string.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test("", S(""), true);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);
     test("abcdefghij", S(""), false);
     test("abcdefghij", S("abcde"), false);
     test("abcdefghij", S("abcdefghij"), true);
     test("abcdefghij", S("abcdefghijklmnopqrst"), false);
     test("abcdefghijklmnopqrst", S(""), false);
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);
     test("abcdefghij", S(""), false);
     test("abcdefghij", S("abcde"), false);
     test("abcdefghij", S("abcdefghij"), true);
     test("abcdefghij", S("abcdefghijklmnopqrst"), false);
     test("abcdefghijklmnopqrst", S(""), false);
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_operator==/string_pointer.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& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), "", true);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghij"), "", false);
     test(S("abcdefghij"), "abcde", false);
     test(S("abcdefghij"), "abcdefghij", true);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghijklmnopqrst"), "", false);
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghij"), "", false);
     test(S("abcdefghij"), "abcde", false);
     test(S("abcdefghij"), "abcdefghij", true);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghijklmnopqrst"), "", false);
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-    }
 #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.nonmembers/string_operator==/string_string.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& lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), S(""), false);
     test(S("abcdefghij"), S("abcde"), false);
     test(S("abcdefghij"), S("abcdefghij"), true);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), S(""), false);
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), S(""), false);
     test(S("abcdefghij"), S("abcde"), false);
     test(S("abcdefghij"), S("abcdefghij"), true);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), S(""), false);
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_operator==/string_string_view.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& lhs, SV rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), SV(""), false);
     test(S("abcdefghij"), SV("abcde"), false);
     test(S("abcdefghij"), SV("abcdefghij"), true);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), SV(""), false);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), SV(""), false);
     test(S("abcdefghij"), SV("abcde"), false);
     test(S("abcdefghij"), SV("abcdefghij"), true);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), SV(""), false);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_operator==/string_view_string.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(SV lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghij"), S(""), false);
     test(SV("abcdefghij"), S("abcde"), false);
     test(SV("abcdefghij"), S("abcdefghij"), true);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghijklmnopqrst"), S(""), false);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghij"), S(""), false);
     test(SV("abcdefghij"), S("abcde"), false);
     test(SV("abcdefghij"), S("abcdefghij"), true);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghijklmnopqrst"), S(""), false);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_opgt/pointer_string.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test("", S(""), false);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);
     test("abcdefghij", S(""), true);
     test("abcdefghij", S("abcde"), true);
     test("abcdefghij", S("abcdefghij"), false);
     test("abcdefghij", S("abcdefghijklmnopqrst"), false);
     test("abcdefghijklmnopqrst", S(""), true);
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);
     test("abcdefghij", S(""), true);
     test("abcdefghij", S("abcde"), true);
     test("abcdefghij", S("abcdefghij"), false);
     test("abcdefghij", S("abcdefghijklmnopqrst"), false);
     test("abcdefghijklmnopqrst", S(""), true);
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_opgt/string_pointer.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& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), "", false);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghij"), "", true);
     test(S("abcdefghij"), "abcde", true);
     test(S("abcdefghij"), "abcdefghij", false);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghijklmnopqrst"), "", true);
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghij"), "", true);
     test(S("abcdefghij"), "abcde", true);
     test(S("abcdefghij"), "abcdefghij", false);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghijklmnopqrst"), "", true);
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-    }
 #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.nonmembers/string_opgt/string_string.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& lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), S(""), true);
     test(S("abcdefghij"), S("abcde"), true);
     test(S("abcdefghij"), S("abcdefghij"), false);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), S(""), true);
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), S(""), true);
     test(S("abcdefghij"), S("abcde"), true);
     test(S("abcdefghij"), S("abcdefghij"), false);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), S(""), true);
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_opgt/string_string_view.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& lhs, SV rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), SV(""), true);
     test(S("abcdefghij"), SV("abcde"), true);
     test(S("abcdefghij"), SV("abcdefghij"), false);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), SV(""), true);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), SV(""), true);
     test(S("abcdefghij"), SV("abcde"), true);
     test(S("abcdefghij"), SV("abcdefghij"), false);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), SV(""), true);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_opgt/string_view_string.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(SV lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghij"), S(""), true);
     test(SV("abcdefghij"), S("abcde"), true);
     test(SV("abcdefghij"), S("abcdefghij"), false);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghijklmnopqrst"), S(""), true);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghij"), S(""), true);
     test(SV("abcdefghij"), S("abcde"), true);
     test(SV("abcdefghij"), S("abcdefghij"), false);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghijklmnopqrst"), S(""), true);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_opgt=/pointer_string.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test("", S(""), true);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);
     test("abcdefghij", S(""), true);
     test("abcdefghij", S("abcde"), true);
     test("abcdefghij", S("abcdefghij"), true);
     test("abcdefghij", S("abcdefghijklmnopqrst"), false);
     test("abcdefghijklmnopqrst", S(""), true);
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
     test("", S("abcdefghijklmnopqrst"), false);
     test("abcde", S(""), true);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), false);
     test("abcde", S("abcdefghijklmnopqrst"), false);
     test("abcdefghij", S(""), true);
     test("abcdefghij", S("abcde"), true);
     test("abcdefghij", S("abcdefghij"), true);
     test("abcdefghij", S("abcdefghijklmnopqrst"), false);
     test("abcdefghijklmnopqrst", S(""), true);
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_opgt=/string_pointer.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& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), "", true);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghij"), "", true);
     test(S("abcdefghij"), "abcde", true);
     test(S("abcdefghij"), "abcdefghij", true);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghijklmnopqrst"), "", true);
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
     test(S(""), "abcdefghijklmnopqrst", false);
     test(S("abcde"), "", true);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", false);
     test(S("abcde"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghij"), "", true);
     test(S("abcdefghij"), "abcde", true);
     test(S("abcdefghij"), "abcdefghij", true);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
     test(S("abcdefghijklmnopqrst"), "", true);
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-    }
 #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.nonmembers/string_opgt=/string_string.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& lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), S(""), true);
     test(S("abcdefghij"), S("abcde"), true);
     test(S("abcdefghij"), S("abcdefghij"), true);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), S(""), true);
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
     test(S(""), S("abcdefghijklmnopqrst"), false);
     test(S("abcde"), S(""), true);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), false);
     test(S("abcde"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), S(""), true);
     test(S("abcdefghij"), S("abcde"), true);
     test(S("abcdefghij"), S("abcdefghij"), true);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), S(""), true);
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_opgt=/string_string_view.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& lhs, SV rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), SV(""), true);
     test(S("abcdefghij"), SV("abcde"), true);
     test(S("abcdefghij"), SV("abcdefghij"), true);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), SV(""), true);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
     test(S(""), SV("abcdefghijklmnopqrst"), false);
     test(S("abcde"), SV(""), true);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), false);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghij"), SV(""), true);
     test(S("abcdefghij"), SV("abcde"), true);
     test(S("abcdefghij"), SV("abcdefghij"), true);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
     test(S("abcdefghijklmnopqrst"), SV(""), true);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_opgt=/string_view_string.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(SV lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghij"), S(""), true);
     test(SV("abcdefghij"), S("abcde"), true);
     test(SV("abcdefghij"), S("abcdefghij"), true);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghijklmnopqrst"), S(""), true);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
     test(SV(""), S("abcdefghijklmnopqrst"), false);
     test(SV("abcde"), S(""), true);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), false);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghij"), S(""), true);
     test(SV("abcdefghij"), S("abcde"), true);
     test(SV("abcdefghij"), S("abcdefghij"), true);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
     test(SV("abcdefghijklmnopqrst"), S(""), true);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_oplt/pointer_string.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test("", S(""), false);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);
     test("abcdefghij", S(""), false);
     test("abcdefghij", S("abcde"), false);
     test("abcdefghij", S("abcdefghij"), false);
     test("abcdefghij", S("abcdefghijklmnopqrst"), true);
     test("abcdefghijklmnopqrst", S(""), false);
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), false);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), false);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);
     test("abcdefghij", S(""), false);
     test("abcdefghij", S("abcde"), false);
     test("abcdefghij", S("abcdefghij"), false);
     test("abcdefghij", S("abcdefghijklmnopqrst"), true);
     test("abcdefghijklmnopqrst", S(""), false);
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_oplt/string_pointer.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& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), "", false);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghij"), "", false);
     test(S("abcdefghij"), "abcde", false);
     test(S("abcdefghij"), "abcdefghij", false);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghijklmnopqrst"), "", false);
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", false);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", false);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghij"), "", false);
     test(S("abcdefghij"), "abcde", false);
     test(S("abcdefghij"), "abcdefghij", false);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghijklmnopqrst"), "", false);
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-    }
 #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.nonmembers/string_oplt/string_string.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& lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), S(""), false);
     test(S("abcdefghij"), S("abcde"), false);
     test(S("abcdefghij"), S("abcdefghij"), false);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), S(""), false);
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), false);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), false);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), S(""), false);
     test(S("abcdefghij"), S("abcde"), false);
     test(S("abcdefghij"), S("abcdefghij"), false);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), S(""), false);
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_oplt/string_string_view.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& lhs, SV rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), SV(""), false);
     test(S("abcdefghij"), SV("abcde"), false);
     test(S("abcdefghij"), SV("abcdefghij"), false);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), SV(""), false);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), false);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), SV(""), false);
     test(S("abcdefghij"), SV("abcde"), false);
     test(S("abcdefghij"), SV("abcdefghij"), false);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), SV(""), false);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_oplt/string_view_string.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(SV lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghij"), S(""), false);
     test(SV("abcdefghij"), S("abcde"), false);
     test(SV("abcdefghij"), S("abcdefghij"), false);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghijklmnopqrst"), S(""), false);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), false);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghij"), S(""), false);
     test(SV("abcdefghij"), S("abcde"), false);
     test(SV("abcdefghij"), S("abcdefghij"), false);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghijklmnopqrst"), S(""), false);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-    }
 #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.nonmembers/string_oplt=/pointer_string.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test("", S(""), true);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);
     test("abcdefghij", S(""), false);
     test("abcdefghij", S("abcde"), false);
     test("abcdefghij", S("abcdefghij"), true);
     test("abcdefghij", S("abcdefghijklmnopqrst"), true);
     test("abcdefghijklmnopqrst", S(""), false);
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test("", S(""), true);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
     test("", S("abcdefghijklmnopqrst"), true);
     test("abcde", S(""), false);
     test("abcde", S("abcde"), true);
     test("abcde", S("abcdefghij"), true);
     test("abcde", S("abcdefghijklmnopqrst"), true);
     test("abcdefghij", S(""), false);
     test("abcdefghij", S("abcde"), false);
     test("abcdefghij", S("abcdefghij"), true);
     test("abcdefghij", S("abcdefghijklmnopqrst"), true);
     test("abcdefghijklmnopqrst", S(""), false);
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_oplt=/string_pointer.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& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), "", true);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghij"), "", false);
     test(S("abcdefghij"), "abcde", false);
     test(S("abcdefghij"), "abcdefghij", true);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghijklmnopqrst"), "", false);
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), "", true);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
     test(S(""), "abcdefghijklmnopqrst", true);
     test(S("abcde"), "", false);
     test(S("abcde"), "abcde", true);
     test(S("abcde"), "abcdefghij", true);
     test(S("abcde"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghij"), "", false);
     test(S("abcdefghij"), "abcde", false);
     test(S("abcdefghij"), "abcdefghij", true);
     test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
     test(S("abcdefghijklmnopqrst"), "", false);
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-    }
 #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.nonmembers/string_oplt=/string_string.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& lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), S(""), false);
     test(S("abcdefghij"), S("abcde"), false);
     test(S("abcdefghij"), S("abcdefghij"), true);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), S(""), false);
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), S(""), true);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
     test(S(""), S("abcdefghijklmnopqrst"), true);
     test(S("abcde"), S(""), false);
     test(S("abcde"), S("abcde"), true);
     test(S("abcde"), S("abcdefghij"), true);
     test(S("abcde"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), S(""), false);
     test(S("abcdefghij"), S("abcde"), false);
     test(S("abcdefghij"), S("abcdefghij"), true);
     test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), S(""), false);
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_oplt=/string_string_view.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& lhs, SV rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), SV(""), false);
     test(S("abcdefghij"), SV("abcde"), false);
     test(S("abcdefghij"), SV("abcdefghij"), true);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), SV(""), false);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
     test(S(""), SV("abcdefghijklmnopqrst"), true);
     test(S("abcde"), SV(""), false);
     test(S("abcde"), SV("abcde"), true);
     test(S("abcde"), SV("abcdefghij"), true);
     test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghij"), SV(""), false);
     test(S("abcdefghij"), SV("abcde"), false);
     test(S("abcdefghij"), SV("abcdefghij"), true);
     test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
     test(S("abcdefghijklmnopqrst"), SV(""), false);
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-    }
 #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.nonmembers/string_oplt=/string_view_string.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(SV lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghij"), S(""), false);
     test(SV("abcdefghij"), S("abcde"), false);
     test(SV("abcdefghij"), S("abcdefghij"), true);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghijklmnopqrst"), S(""), false);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::basic_string_view<char, std::char_traits<char>> SV;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
     test(SV(""), S("abcdefghijklmnopqrst"), true);
     test(SV("abcde"), S(""), false);
     test(SV("abcde"), S("abcde"), true);
     test(SV("abcde"), S("abcdefghij"), true);
     test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghij"), S(""), false);
     test(SV("abcdefghij"), S("abcde"), false);
     test(SV("abcdefghij"), S("abcdefghij"), true);
     test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
     test(SV("abcdefghijklmnopqrst"), S(""), false);
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }