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

[philnik]

• Comment out static_assert

[ldionne]

My expectation is that the commit that will actually implement constexpr string should then only uncomment those static_asserts and also should make the necessary changes in std::basic_string. That's exactly how this should be done, so this is great, however I am left wondering if that's really all the test changes that are going to be necessary.

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

27–28

Missing TEST_CONSTEXPR_CXX20.

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

21

Missing TEST_CONSTEXPR_CXX20.

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

26–27

Missing TEST_CONSTEXPR_CXX20. I think several other functions below are missing it too, so I'll stop here.

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

104

All of those should be

#if TEST_STD_VER > 17
  // static_assert(test());
#endif

[philnik]

• Add version guards

[philnik]

@ldionne No, they aren't all the changes, but most of them. I first want to make these very easy to verify changes and then the actual behavioral changes.
I think most of the rest are ignoring exception tests during constant evaluation, but I think it will be easier for everybody if I put all the else if (!TEST_IS_CONSTANT_EVALUATED) into a single PR.

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

27–28

The problem is that clang will warn on these. They aren't templates, so they have to be made constexpr with the functional changes.

[ldionne]

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

27–28

Oh, of course. Otherwise Clang complains about a constexpr function never being constexpr-friendly.

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

 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos)
 {
     const S& cs = s;
     if (pos < s.size())
     {
         assert(s.at(pos) == s[pos]);
         assert(cs.at(pos) == cs[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);
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
     test(S("123"), 3);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0);
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
     test(S("123"), 3);
-    }
 #endif
 
+    return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     const S& cs = s;
     ASSERT_SAME_TYPE(decltype( s.back()), typename S::reference);
     ASSERT_SAME_TYPE(decltype(cs.back()), typename S::const_reference);
     LIBCPP_ASSERT_NOEXCEPT(    s.back());
     LIBCPP_ASSERT_NOEXCEPT(   cs.back());
     assert(&cs.back() == &cs[cs.size()-1]);
     assert(&s.back() == &s[cs.size()-1]);
     s.back() = typename S::value_type('z');
     assert(s.back() == typename S::value_type('z'));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
 #endif
 
-    return 0;
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
 }

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     const S& cs = s;
     ASSERT_SAME_TYPE(decltype( s.front()), typename S::reference);
     ASSERT_SAME_TYPE(decltype(cs.front()), typename S::const_reference);
     LIBCPP_ASSERT_NOEXCEPT(    s.front());
     LIBCPP_ASSERT_NOEXCEPT(   cs.front());
     assert(&cs.front() == &cs[0]);
     assert(&s.front() == &s[0]);
     s.front() = typename S::value_type('z');
     assert(s.front() == typename S::value_type('z'));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
 #endif
 
-    return 0;
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
 }

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

 //       reference operator[](size_type pos);
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     S s("0123456789");
     const S& cs = s;
     ASSERT_SAME_TYPE(decltype( s[0]), typename S::reference);
     ASSERT_SAME_TYPE(decltype(cs[0]), typename S::const_reference);
     LIBCPP_ASSERT_NOEXCEPT(    s[0]);
     LIBCPP_ASSERT_NOEXCEPT(   cs[0]);
     for (S::size_type i = 0; i < cs.size(); ++i)
     {
         assert(s[i] == static_cast<char>('0' + i));
         assert(cs[i] == s[i]);
     }
     assert(cs[cs.size()] == '\0');
     const S s2 = S();
     assert(s2[0] == '\0');
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s("0123456789");
     const S& cs = s;
     ASSERT_SAME_TYPE(decltype( s[0]), typename S::reference);
     ASSERT_SAME_TYPE(decltype(cs[0]), typename S::const_reference);
     LIBCPP_ASSERT_NOEXCEPT(    s[0]);
     LIBCPP_ASSERT_NOEXCEPT(   cs[0]);
     for (S::size_type i = 0; i < cs.size(); ++i)
     {
         assert(s[i] == static_cast<char>('0' + i));
         assert(cs[i] == s[i]);
     }
     assert(cs[cs.size()] == '\0');
     const S s2 = S();
     assert(s2[0] == '\0');
-    }
 #endif
 
-    return 0;
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
 }

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

 #include "test_allocator.h"
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
 test_allocator_statistics alloc_stats;
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     alloc_stats.throw_after = 0;
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
 #endif
     {
         while (s.size() < s.capacity())
             s.push_back(typename S::value_type());
         assert(s.size() == s.capacity());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     catch (...)
     {
         assert(false);
     }
 #endif
     alloc_stats.throw_after = INT_MAX;
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
     S s((test_allocator<char>(&alloc_stats)));
     test(s);
     s.assign(10, 'a');
     s.erase(5);
     test(s);
     s.assign(100, 'a');
     s.erase(50);
     test(s);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     assert(s.capacity() > 0);
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

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

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

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

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

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

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

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

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

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

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

test(const S& s)
     assert(s.max_size() >= s.size());
     S s2(s);
     const size_t sz = s2.max_size() + 1;
     try { s2.resize(sz, 'x'); }
     catch ( const std::length_error & ) { return ; }
     assert ( false );
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(typename S::size_type min_cap, typename S::size_type erased_index)
 {
     S s(min_cap, 'a');
     s.erase(erased_index);
     assert(s.size() == erased_index);
     assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
 
     typename S::size_type old_cap = s.capacity();
     S s0 = s;
     s.reserve();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef std::string S;
     {
     test<S>(0, 0);
     test<S>(10, 5);
     test<S>(100, 50);
     }
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     {
     test<S>(0, 0);
     test<S>(10, 5);
     test<S>(100, 50);
     }
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

else
         catch (std::length_error&)
         {
             assert(res_arg > s.max_size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     {
       test<S>(0, 0, 5);
       test<S>(0, 0, 10);
       test<S>(0, 0, 50);
     }
     {
       test<S>(100, 50, 5);
       test<S>(100, 50, 10);
       test<S>(100, 50, 50);
       test<S>(100, 50, 100);
       test<S>(100, 50, 1000);
       test<S>(100, 50, S::npos);
     }
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     {
       test<S>(0, 0, 5);
       test<S>(0, 0, 10);
       test<S>(0, 0, 50);
     }
     {
       test<S>(100, 50, 5);
       test<S>(100, 50, 10);
       test<S>(100, 50, 50);
       test<S>(100, 50, 100);
       test<S>(100, 50, 1000);
       test<S>(100, 50, S::npos);
     }
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, S expected)
 {
     if (n <= s.max_size())
     {
         s.resize(n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
             s.resize(n);
             assert(false);
         }
         catch (std::length_error&)
         {
             assert(n > s.max_size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), 0, S());
     test(S(), 1, S(1, '\0'));
     test(S(), 10, S(10, '\0'));
     test(S(), 100, S(100, '\0'));
     test(S("12345"), 0, S());
     test(S("12345"), 2, S("12"));
     test(S("12345"), 5, S("12345"));
     test(S("12345"), 15, S("12345\0\0\0\0\0\0\0\0\0\0", 15));
     test(S("12345678901234567890123456789012345678901234567890"), 0, S());
     test(S("12345678901234567890123456789012345678901234567890"), 10,
          S("1234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 50,
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60,
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
     test(S(), S::npos, S("not going to happen"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, S());
     test(S(), 1, S(1, '\0'));
     test(S(), 10, S(10, '\0'));
     test(S(), 100, S(100, '\0'));
     test(S("12345"), 0, S());
     test(S("12345"), 2, S("12"));
     test(S("12345"), 5, S("12345"));
     test(S("12345"), 15, S("12345\0\0\0\0\0\0\0\0\0\0", 15));
     test(S("12345678901234567890123456789012345678901234567890"), 0, S());
     test(S("12345678901234567890123456789012345678901234567890"), 10,
          S("1234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 50,
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60,
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
     test(S(), S::npos, S("not going to happen"));
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

else
         catch (std::length_error&)
         {
             assert(n > s.max_size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S("a"));
     test(S(), 10, 'a', S(10, 'a'));
     test(S(), 100, 'a', S(100, 'a'));
     test(S("12345"), 0, 'a', S());
     test(S("12345"), 2, 'a', S("12"));
     test(S("12345"), 5, 'a', S("12345"));
     test(S("12345"), 15, 'a', S("12345aaaaaaaaaa"));
     test(S("12345678901234567890123456789012345678901234567890"), 0, 'a', S());
     test(S("12345678901234567890123456789012345678901234567890"), 10, 'a',
          S("1234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 50, 'a',
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
     test(S(), S::npos, 'a', S("not going to happen"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S("a"));
     test(S(), 10, 'a', S(10, 'a'));
     test(S(), 100, 'a', S(100, 'a'));
     test(S("12345"), 0, 'a', S());
     test(S("12345"), 2, 'a', S("12"));
     test(S("12345"), 5, 'a', S("12345"));
     test(S("12345"), 15, 'a', S("12345aaaaaaaaaa"));
     test(S("12345678901234567890123456789012345678901234567890"), 0, 'a', S());
     test(S("12345678901234567890123456789012345678901234567890"), 10, 'a',
          S("1234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 50, 'a',
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
     test(S(), S::npos, 'a', S("not going to happen"));
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

test(S s)
     S s0 = s;
     s.shrink_to_fit();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef std::string S;
     S s;
     test(s);
 
     s.assign(10, 'a');
     s.erase(5);
     test(s);
#if TEST_STD_VER >= 11
     test(s);
 
     s.assign(100, 'a');
     s.erase(50);
     test(s);
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/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::size_type c)
 {
     assert(s.size() == c);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), 0);
     test(S("123"), 3);
     test(S("12345678901234567890123456789012345678901234567890"), 50);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 0);
     test(S("123"), 3);
     test(S("12345678901234567890123456789012345678901234567890"), 50);
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV sv, std::size_t pos, std::size_t n)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     typedef typename S::size_type Size;
     if (pos <= sv.size())
     {
         S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
else
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a)
 {
     typedef typename S::traits_type T;
     typedef typename S::size_type Size;
     if (pos <= sv.size())
     {
         S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
         LIBCPP_ASSERT(s2.__invariants());
else
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-
-    {
+bool test() {
     typedef test_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
     typedef std::basic_string     <char, std::char_traits<char>, A> S;
 
     test<S,SV>(SV(), 0, 0);
     test<S,SV>(SV(), 0, 1);
     test<S,SV>(SV(), 1, 0);
     test<S,SV>(SV(), 1, 1);
bool test() {
     test<S,SV>(SV(), 1, 1, A(4));
     test<S,SV>(SV(), 1, 2, A(4));
     test<S,SV>(SV("1"), 0, 0, A(6));
     test<S,SV>(SV("1"), 0, 1, A(6));
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   0, A(8));
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   1, A(8));
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,  10, A(8));
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A(8));
-    }
 
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
     typedef std::basic_string     <char, std::char_traits<char>, A> S;
 
     test<S,SV>(SV(), 0, 0);
     test<S,SV>(SV(), 0, 1);
     test<S,SV>(SV(), 1, 0);
     test<S,SV>(SV(), 1, 1);
#if TEST_STD_VER >= 11
     test<S,SV>(SV(), 1, 1, A());
     test<S,SV>(SV(), 1, 2, A());
     test<S,SV>(SV("1"), 0, 0, A());
     test<S,SV>(SV("1"), 0, 1, A());
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0, A());
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1, A());
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10, A());
     test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A());
-    }
 #endif
-    {
     typedef std::string S;
     typedef std::string_view SV;
     S s = "ABCD";
     SV sv = "EFGH";
     char arr[] = "IJKL";
 
     S s1("CDEF", 4);    // calls ctor(const char *, len)
     assert(s1 == "CDEF");
#endif
     S s5(arr, 0, 2);     // calls ctor(const char *, len)
     assert(s5 == "IJ");
 
     S s6(arr, 0);     // calls ctor(const char *, len)
     assert(s6 == "");
 
     S s7(s.data(), 2);     // calls ctor(const char *, len)
     assert(s7 == "AB");
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #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()
 {
     {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
#endif
     assert(s.capacity() >= s.size());
     assert(s.get_allocator() == typename S::allocator_type(5));
     }
 }
 
 #if TEST_STD_VER >= 11
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test2()
 {
     {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
#endif
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
     assert(s.get_allocator() == typename S::allocator_type());
     }
 }
 
 #endif
 
-int main(int, char**)
-{
-    test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
+bool test() {
 #if TEST_STD_VER >= 11
-    test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
-    test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 // basic_string<charT,traits,Allocator>&
 //   operator=(basic_string<charT,traits,Allocator>&& str);
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
+bool test() {
   // Test that assignment from {} and {ptr, len} are allowed and are not
   // ambiguous.
   {
     std::string s = "hello world";
     s = {};
     assert(s.empty());
   }
   {
     std::string s = "hello world";
     s = {"abc", 2};
     assert(s == "ab");
   }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

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

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

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

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

 {
     S s2(s1, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A(3));
     test(S("1"), A(5));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-    }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     const char * p1 = "This is my first string";
     const char * p2 = "This is my second string";
 
     alloc_imp imp1;
     alloc_imp imp2;
     S s1(p1, A(&imp1));
     S s2(p2, A(&imp2));
 
     assert(s1 == p1);
     assert(s2 == p2);
 
     imp2.deactivate();
     test_assign(s1, s2);
     assert(s1 == p1);
     assert(s2 == p2);
-    }
 #endif
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, const S& s2)
 {
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1 == s2);
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S());
     test(S("1"), S());
     test(S(), S("1"));
     test(S("1"), S("2"));
     test(S("1"), S("2"));
 
     test(S(),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("123456789"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
     test(S("1"), S());
     test(S(), S("1"));
     test(S("1"), S("2"));
     test(S("1"), S("2"));
 
     test(S(),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("123456789"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
     std::string s;
     s = {"abc", 1};
     assert(s.size() == 1);
     assert(s == "a");
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 // (8)  basic_string(InputIt, InputIt, A const& = A()) - BROKEN
 // (9)  basic_string(BS const&)
 // (10) basic_string(BS const&, A const&)
 // (11) basic_string(BS&&)
 // (12) basic_string(BS&&, A const&)
 // (13) basic_string(initializer_list<CharT>, A const& = A())
 // (14) basic_string(BSV, A const& = A())
 // (15) basic_string(const T&, size_type, size_type, A const& = A())
-int main(int, char**)
-{
+bool test() {
+
   using TestSizeT = test_allocator<char>::size_type;
   { // Testing (1)
     // Nothing to do. Cannot deduce without any arguments.
   }
   { // Testing (2)
     // This overload isn't compatible with implicit deduction guides as
     // specified in the standard.
     // const test_allocator<char> alloc{};
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t>>;
     ExpectW w0(L"abcdef");
     std::basic_string w(w0, 2, 2, test_allocator<wchar_t>{6});
     ASSERT_SAME_TYPE(decltype(w), ExpectW);
     assert(w == L"cd");
 #endif
   }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

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

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

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

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

 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
 template <class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(It first, It last)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::allocator_type A;
     S s2(first, last);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
         assert(s2[i] == *it);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class It, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(It first, It last, const A& a)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     S s2(first, last, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
         assert(s2[i] == *it);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef test_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
 
     test(s, s);
     test(s, s, A(2));
 
     test(s, s+1);
     test(s, s+1, A(2));
bool test() {
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A(2));
 
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A(2));
 
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A(2));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
 
     test(s, s);
     test(s, s, A());
 
     test(s, s+1);
     test(s, s+1, A());
#if TEST_STD_VER >= 11
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A());
 
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A());
 
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
     test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A());
-    }
 #endif
-    {
       static_assert((!std::is_constructible<std::string, std::string,
                                             std::string>::value),
                     "");
       static_assert(
           (!std::is_constructible<std::string, std::string, std::string,
                                   std::allocator<char> >::value),
           "");
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     const char* s = "12345678901234";
     std::basic_string s1(s, s+10);  // Can't use {} here
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-
-    {
     const char* s = "12345678901234";
     std::basic_string s1{s, s+10, std::allocator<char>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-    {
     const wchar_t* s = L"12345678901234";
     std::basic_string s1{s, s+10, test_allocator<wchar_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-    {
     const char16_t* s = u"12345678901234";
     std::basic_string s1{s, s+10, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
-    {
     const char32_t* s = U"12345678901234";
     std::basic_string s1{s, s+10, explicit_allocator<char32_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
     static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
     static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+
   return 0;
 }

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

 #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(S s0)
 {
     S s1 = s0;
     S s2 = std::move(s0);
     LIBCPP_ASSERT(s2.__invariants());
     LIBCPP_ASSERT(s0.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-    }
-    {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A{}));
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #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(S s0, const typename S::allocator_type& a)
 {
     S s1 = s0;
     S s2(std::move(s0), a);
     LIBCPP_ASSERT(s2.__invariants());
     LIBCPP_ASSERT(s0.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    test_allocator_statistics alloc_stats;
-    {
+bool test() {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     test(S(), A(3, &alloc_stats));
     test(S("1"), A(5, &alloc_stats));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7, &alloc_stats));
-    }
 
     int alloc_count = alloc_stats.alloc_count;
-    {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe", A(&alloc_stats));
     S s2 (std::move(s1), A(1, &alloc_stats));
-    }
     assert ( alloc_stats.alloc_count == alloc_count );
-    {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

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

libcxx/test/std/strings/basic.string/string.cons/move_assignment.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(S s1, S s2)
 {
     S s0 = s2;
     s1 = std::move(s2);
     LIBCPP_ASSERT(s1.__invariants());
     LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s0);
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S());
     test(S("1"), S());
     test(S(), S("1"));
     test(S("1"), S("2"));
     test(S("1"), S("2"));
 
     test(S(),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("123456789"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
     test(S("1"), S());
     test(S(), S("1"));
     test(S("1"), S("2"));
     test(S("1"), S("2"));
 
     test(S(),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("123456789"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     std::size_t n = T::length(s);
     S s2(s);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     std::size_t n = T::length(s);
     S s2(s, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef test_allocator<char> A;
 
     test("");
     test("", A(2));
 
     test("1");
     test("1", A(2));
#if TEST_STD_VER >= 11
     test("1234567980");
     test("1234567980", A());
 
     test("123456798012345679801234567980123456798012345679801234567980");
     test("123456798012345679801234567980123456798012345679801234567980", A());
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, const typename S::value_type* s2)
 {
     typedef typename S::traits_type T;
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == T::length(s2));
     assert(T::compare(s1.data(), s2, s1.size()) == 0);
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), "");
     test(S("1"), "");
     test(S(), "1");
     test(S("1"), "2");
     test(S("1"), "2");
 
     test(S(),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     test(S("123456789"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "");
     test(S("1"), "");
     test(S(), "1");
     test(S("1"), "2");
     test(S("1"), "2");
 
     test(S(),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     test(S("123456789"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s, unsigned n)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(s, n);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const charT* s, unsigned n, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     S s2(s, n, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef test_allocator<char> A;
 
     test("", 0);
     test("", 0, A(2));
 
     test("1", 1);
     test("1", 1, A(2));
 
     test("1234567980", 10);
     test("1234567980", 10, A(2));
 
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A(2));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
 
     test("", 0);
     test("", 0, A());
 
     test("1", 1);
     test("1", 1, A());
 
     test("1234567980", 10);
     test("1234567980", 10, A());
 
     test("123456798012345679801234567980123456798012345679801234567980", 60);
     test("123456798012345679801234567980123456798012345679801234567980", 60, A());
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
     std::string s({"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
-void
+TEST_CONSTEXPR_CXX20 void
 test(unsigned n, charT c)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::allocator_type A;
     S s2(n, c);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(unsigned n, charT c, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     S s2(n, c, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
test(Tp n, Tp c)
     assert(s2.size() == static_cast<std::size_t>(n));
     for (int i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(Tp n, Tp c, const A& a)
 {
     typedef char charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     S s2(n, c, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(n));
     for (int i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef test_allocator<char> A;
 
     test(0, 'a');
     test(0, 'a', A(2));
 
     test(1, 'a');
     test(1, 'a', A(2));
 
     test(10, 'a');
     test(10, 'a', A(2));
 
     test(100, 'a');
     test(100, 'a', A(2));
 
     test(static_cast<char>(100), static_cast<char>(65));
     test(static_cast<char>(100), static_cast<char>(65), A(3));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
 
     test(0, 'a');
     test(0, 'a', A());
 
     test(1, 'a');
     test(1, 'a', A());
 
     test(10, 'a');
     test(10, 'a', A());
 
     test(100, 'a');
     test(100, 'a', A());
 
     test(static_cast<char>(100), static_cast<char>(65));
     test(static_cast<char>(100), static_cast<char>(65), A());
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

test(std::basic_string_view<charT> sv, const A& a)
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
   }
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef test_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
 
     test(SV(""));
     test(SV(""), A(2));
 
     test(SV("1"));
     test(SV("1") ,A(2));
 
     test(SV("1234567980"));
     test(SV("1234567980"), A(2));
 
     test(SV("123456798012345679801234567980123456798012345679801234567980"));
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A(2));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
 
     test(SV(""));
     test(SV(""), A());
 
     test(SV("1"));
     test(SV("1") ,A());
 
     test(SV("1234567980"));
     test(SV("1234567980"), A());
 
     test(SV("123456798012345679801234567980123456798012345679801234567980"));
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A());
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, SV sv)
 {
     typedef typename S::traits_type T;
     s1 = sv;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == sv.size());
     assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
     assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(""));
     test(S("1"), SV(""));
     test(S(), SV("1"));
     test(S("1"), SV("2"));
     test(S("1"), SV("2"));
 
     test(S(),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("123456789"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test(S(), SV(""));
     test(S("1"), SV(""));
     test(S(), SV("1"));
     test(S("1"), SV("2"));
     test(S("1"), SV("2"));
 
     test(S(),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("123456789"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     std::string_view sv = "12345678901234";
     std::basic_string s1(sv);
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 
-    {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, std::allocator<char>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, test_allocator<wchar_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 #endif
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
-    {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, min_allocator<char8_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 #endif
-    {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
-    {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, explicit_allocator<char32_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
     static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
     static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 
-    {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4, std::allocator<char>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, 0, 4, test_allocator<wchar_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 #endif
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
-    {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char8_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 #endif
-    {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
-    {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, 0, 4, explicit_allocator<char32_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
     static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
     static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
-    }
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

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

 #include <scoped_allocator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
 
     if (pos <= str.size())
     {
         S s2(str, pos);
else
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos, unsigned n)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     if (pos <= str.size())
     {
         S s2(str, pos, n);
         LIBCPP_ASSERT(s2.__invariants());
else
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
 {
     typedef typename S::traits_type T;
 
     if (pos <= str.size())
     {
         S s2(str, pos, n, a);
         LIBCPP_ASSERT(s2.__invariants());
void test2583()
 
     try { vs.emplace_back(s, 5); }
     catch (const std::out_of_range&) { return; }
     assert(false);
 }
 #endif
 #endif
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test(S(A(3)), 0);
     test(S(A(3)), 1);
     test(S("1", A(5)), 0);
     test(S("1", A(5)), 1);
     test(S("1", A(5)), 2);
bool test() {
     test(S(A(3)), 1, 1, A(4));
     test(S(A(3)), 1, 2, A(4));
     test(S("1", A(5)), 0, 0, A(6));
     test(S("1", A(5)), 0, 1, A(6));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test(S(A()), 0);
     test(S(A()), 1);
     test(S("1", A()), 0);
     test(S("1", A()), 1);
     test(S("1", A()), 2);
#if TEST_STD_VER >= 11
     test(S(A()), 1, 1, A());
     test(S(A()), 1, 2, A());
     test(S("1", A()), 0, 0, A());
     test(S("1", A()), 0, 1, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
-    }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    test2583();
 #endif
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }