[libc++] Prepare string.modifiers tests for constexpr

[ldionne]

Looks pretty good, with some comments.

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

1832

Instead, can you do

template <class S, class V>
_LIBCPP_CONSTEXPR_AFTER_CXX17 void tests() {
  test0<S, SV>();
  // ...
  test31<S, SV>();
}

bool check_all() {
  tests<std::string, std::string_view>();
#if TEST_STD_VER >= 11
  tests<std::basic_string<char, std::char_traits<char>, min_allocator<char>>,
        std::basic_string_view<char, std::char_traits<char>>>();
#endif
  return true;
}

int main() {
  check_all();
#if TEST_STD_VER > 17
  static_assert(check_all());
#endif
}

You can also tweak test31 to be templated like the other ones, I think you only need to use the SV() macro and friends in it.

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

1861

Same comment as above.

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

1047

Same comment as above.

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp

983

Same comment as above.

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

6020

Same comment as above.

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

1324

Here too.

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

6094

Here too.

[philnik]

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

1832

I can't, because you can "only" do about 1 million steps during constant evaluation. If everything is in a single static_assert() that limit is reached. I can of course make test 31 a template.

[• Quuxplusone]

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

1832

FWIW, a quick skim did not enlighten me as to why we need exactly these 32 opaquely numbered test cases here. What's the purpose of each of these tests? Can we get the "length" of this test down below a million simply by improving it?
I see we might want to test every possible cell in the matrix (short,long) x (0,1,3,n-1,n,n+1) x (short,long) x (0,1,3,n-1,n,n+1) x (0,1,2,3,4,n-1,n,n+1) but even that's only 1152 different test cases, and we've got 1843 lines in the left-hand file here.

[philnik]

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

1832

I don't think we would get it below a million without decreasing test coverage. If I remember correctly clang compiled about the first 10 functions until it errored. Anyways, that's definitely out of scope for this PR.

[philnik]

• Fix CI

[ldionne]

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

1832

I can't, because you can "only" do about 1 million steps during constant evaluation. If everything is in a single static_assert() that limit is reached. I can of course make test 31 a template.

Interesting -- things are never as simple as they seem.

I'd still like for test31 to be a template, like the other ones.

[philnik]

• Make testN templates

[ldionne]

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

1832

Hmm, incidentally, I thought we were instantiating those tests with wchar_t, not only char. That's why I said "use the SV macro", confusing it with the MAKE_STRING macro we use elsewhere. My comment must not have made much sense. Anyway, LGTM.

libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 #include <cassert>
 #include <string>
 
+#include "test_macros.h"
+
 struct Incomplete;
 template<class T> struct Holder { T t; };
 
 template<class T>
 struct Charlike {
     char ch_;
     Charlike(char ch) : ch_(ch) {}
     operator char() const { return ch_; }
 };
 
-int main(int, char**)
-{
-    std::string s;
-    Charlike<Holder<Incomplete> > a[] = {'m', 'a', 'h', 'i'};
-    s.append(a, a+4);
-    s.assign(a, a+4);
-    s.insert(s.begin(), a, a+4);
-    s.replace(s.begin(), s.begin()+4, a, a+4);
-    assert(s == "mahimahi");
+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.modifiers/string_append/T_size_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
     {
         s.append(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
else
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, SV sv, typename S::size_type pos, S expected)
 {
     if (pos <= sv.size())
     {
         s.append(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
             s.append(sv, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(), 0, 0, S());
     test(S(), SV(), 1, 0, S());
     test(S(), SV("12345"), 0, 3, S("123"));
     test(S(), SV("12345"), 1, 4, S("2345"));
     test(S(), SV("12345"), 3, 15, S("45"));
     test(S(), SV("12345"), 5, 15, S(""));
     test(S(), SV("12345"), 6, 15, S("not happening"));
     test(S(), SV("12345678901234567890"), 0, 0, S());
     test(S(), SV("12345678901234567890"), 1, 1, S("2"));
     test(S(), SV("12345678901234567890"), 2, 3, S("345"));
     test(S(), SV("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), SV("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), SV(), 0, 0, S("12345"));
     test(S("12345"), SV("12345"), 2, 2, S("1234534"));
     test(S("12345"), SV("1234567890"), 0, 100, S("123451234567890"));
 
     test(S("12345678901234567890"), SV(), 0, 0, S("12345678901234567890"));
     test(S("12345678901234567890"), SV("12345"), 1, 3, S("12345678901234567890234"));
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
-    }
 #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(), 0, 0, S());
     test(S(), SV(), 1, 0, S());
     test(S(), SV("12345"), 0, 3, S("123"));
     test(S(), SV("12345"), 1, 4, S("2345"));
     test(S(), SV("12345"), 3, 15, S("45"));
     test(S(), SV("12345"), 5, 15, S(""));
     test(S(), SV("12345"), 6, 15, S("not happening"));
     test(S(), SV("12345678901234567890"), 0, 0, S());
     test(S(), SV("12345678901234567890"), 1, 1, S("2"));
     test(S(), SV("12345678901234567890"), 2, 3, S("345"));
     test(S(), SV("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), SV("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), SV(), 0, 0, S("12345"));
     test(S("12345"), SV("12345"), 2, 2, S("1234534"));
     test(S("12345"), SV("1234567890"), 0, 100, S("123451234567890"));
 
     test(S("12345678901234567890"), SV(), 0, 0, S("12345678901234567890"));
     test(S("12345678901234567890"), SV("12345"), 1, 3, S("12345678901234567890234"));
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
-    }
 #endif
-    {
     typedef std::string S;
     typedef std::string_view SV;
     test_npos(S(), SV(), 0, S());
     test_npos(S(), SV(), 1, S());
     test_npos(S(), SV("12345"), 0, S("12345"));
     test_npos(S(), SV("12345"), 1, S("2345"));
     test_npos(S(), SV("12345"), 3, S("45"));
     test_npos(S(), SV("12345"), 5, S(""));
     test_npos(S(), SV("12345"), 6, S("not happening"));
-    }
 
-    {
     std::string s;
     std::string_view sv = "EFGH";
     char arr[] = "IJKL";
 
     s.append("CDEF", 0);    // calls append(const char *, len)
     assert(s == "");
     s.clear();
 
#endif
 
     s.append(arr, 0, std::string::npos);    // calls append(string("IJKL"), pos, npos)
     assert(s == "IJKL");
     s.clear();
 
     s.append(arr, 0);     // calls append(const char *, len)
     assert(s == "");
     s.clear();
-    }
 
-    {
     std::string s = "ABCD";
     std::string_view sv = s;
     s.append(sv);
     assert(s == "ABCDABCD");
 
     sv = s;
     s.append(sv, 0, std::string::npos);
     assert(s == "ABCDABCDABCDABCD");
 
     sv = s;
     s.append(sv, sv.size());
     assert(s == "ABCDABCDABCDABCD");
-    }
 
-    {
     std::string s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     std::string_view sv = s;
     s.append(sv);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
     sv = s;
     s.append(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
-    }
 
+  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.modifiers/string_append/initializer_list.pass.cpp

 // basic_string& append(initializer_list<charT> il);
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s("123");
-        s.append({'a', 'b', 'c'});
-        assert(s == "123abc");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s("123");
-        s.append({'a', 'b', 'c'});
-        assert(s == "123abc");
-    }
+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.modifiers/string_append/iterator.pass.cpp

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
     s.append(first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, It first, It last)
 {
     S original = s;
     typename S::iterator begin = s.begin();
     typename S::iterator end = s.end();
 
     try {
         s.append(first, last);
         assert(false);
     } catch (...) {}
 
     // Part of "no effects" is that iterators and pointers
     // into the string must not have been invalidated.
     LIBCPP_ASSERT(s.__invariants());
     assert(s == original);
     assert(s.begin() == begin);
     assert(s.end() == end);
 }
 #endif
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s+1, S("A"));
     test(S(), s, s+10, S("ABCDEFGHIJ"));
     test(S(), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), s, s, S("12345"));
bool test() {
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
          S("12345678901234567890"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("12345678901234567890""A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("12345678901234567890""ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s+1, S("A"));
     test(S(), s, s+10, S("ABCDEFGHIJ"));
     test(S(), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), s, s, S("12345"));
#if TEST_STD_VER >= 11
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
          S("12345678901234567890"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("12345678901234567890""A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("12345678901234567890""ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-    }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), w, w+100);
-    }
 #endif
 
-    { // test appending to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.append(s_short.begin(), s_short.end());
     assert(s_short == "123/123/");
     s_short.append(s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/");
     s_short.append(s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.append(s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
-    { // test appending a different type
     typedef std::string S;
     const uint8_t p[] = "ABCD";
 
     S s;
     s.append(p, p + 4);
     assert(s == "ABCD");
-    }
 
-    { // regression-test appending to self in sneaky ways
     std::string s_short = "hello";
     std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
     std::string s_othertype = "hello";
     const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
     std::string s_sneaky = "hello";
 
     test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("hello\0", 6));
     test(s_long, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
          std::string("Lorem ipsum dolor sit amet, consectetur/\0", 41));
     test(s_othertype, first + 2, first + 5, std::string("hellollo"));
 
     s_sneaky.reserve(12);
     test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, std::string("hellohello\0", 11));
-    }
 
   { // test with a move iterator that returns char&&
     typedef forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
   { // test with a move iterator that returns char&&
     typedef const char* It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
 
+  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.modifiers/string_append/pointer.pass.cpp

 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.append(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), "", S());
     test(S(), "12345", S("12345"));
     test(S(), "12345678901234567890", S("12345678901234567890"));
 
     test(S("12345"), "", S("12345"));
     test(S("12345"), "12345", S("1234512345"));
     test(S("12345"), "1234567890", S("123451234567890"));
 
     test(S("12345678901234567890"), "", S("12345678901234567890"));
     test(S("12345678901234567890"), "12345", S("1234567890123456789012345"));
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", S());
     test(S(), "12345", S("12345"));
     test(S(), "12345678901234567890", S("12345678901234567890"));
 
     test(S("12345"), "", S("12345"));
     test(S("12345"), "12345", S("1234512345"));
     test(S("12345"), "1234567890", S("123451234567890"));
 
     test(S("12345678901234567890"), "", S("12345678901234567890"));
     test(S("12345678901234567890"), "12345", S("1234567890123456789012345"));
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
-    }
 #endif
 
-    { // test appending to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.append(s_short.c_str());
     assert(s_short == "123/123/");
     s_short.append(s_short.c_str());
     assert(s_short == "123/123/123/123/");
     s_short.append(s_short.c_str());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.append(s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
+  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.modifiers/string_append/pointer_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, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.append(str, n);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), "", 0, S());
     test(S(), "12345", 3, S("123"));
     test(S(), "12345", 4, S("1234"));
     test(S(), "12345678901234567890", 0, S());
     test(S(), "12345678901234567890", 1, S("1"));
     test(S(), "12345678901234567890", 3, S("123"));
     test(S(), "12345678901234567890", 20, S("12345678901234567890"));
 
     test(S("12345"), "", 0, S("12345"));
     test(S("12345"), "12345", 5, S("1234512345"));
     test(S("12345"), "1234567890", 10, S("123451234567890"));
 
     test(S("12345678901234567890"), "", 0, S("12345678901234567890"));
     test(S("12345678901234567890"), "12345", 5, S("1234567890123456789012345"));
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("1234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", 0, S());
     test(S(), "12345", 3, S("123"));
     test(S(), "12345", 4, S("1234"));
     test(S(), "12345678901234567890", 0, S());
     test(S(), "12345678901234567890", 1, S("1"));
     test(S(), "12345678901234567890", 3, S("123"));
     test(S(), "12345678901234567890", 20, S("12345678901234567890"));
 
     test(S("12345"), "", 0, S("12345"));
     test(S("12345"), "12345", 5, S("1234512345"));
     test(S("12345"), "1234567890", 10, S("123451234567890"));
 
     test(S("12345678901234567890"), "", 0, S("12345678901234567890"));
     test(S("12345678901234567890"), "12345", 5, S("1234567890123456789012345"));
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("1234567890123456789012345678901234567890"));
-    }
 #endif
 
-    { // test appending to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.append(s_short.data(), s_short.size());
     assert(s_short == "123/123/");
     s_short.append(s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/");
     s_short.append(s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.append(s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
+  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.modifiers/string_append/push_back.pass.cpp

 
 struct veryLarge
 {
   long long a;
   char b;
 };
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::value_type c, S expected)
 {
     s.push_back(c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), 'a', S(1, 'a'));
     test(S("12345"), 'a', S("12345a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a', S(1, 'a'));
     test(S("12345"), 'a', S("12345a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-    }
 #endif
 
-    {
 // https://llvm.org/PR31454
     std::basic_string<veryLarge> s;
     veryLarge vl = {};
     s.push_back(vl);
     s.push_back(vl);
     s.push_back(vl);
-    }
 
+  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.modifiers/string_append/size_char.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, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.append(n, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S(1, 'a'));
     test(S(), 10, 'a', S(10, 'a'));
     test(S(), 100, 'a', S(100, 'a'));
 
     test(S("12345"), 0, 'a', S("12345"));
     test(S("12345"), 1, 'a', S("12345a"));
     test(S("12345"), 10, 'a', S("12345aaaaaaaaaa"));
 
     test(S("12345678901234567890"), 0, 'a', S("12345678901234567890"));
     test(S("12345678901234567890"), 1, 'a', S("12345678901234567890a"));
     test(S("12345678901234567890"), 10, 'a', S("12345678901234567890aaaaaaaaaa"));
-    }
 #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(1, 'a'));
     test(S(), 10, 'a', S(10, 'a'));
     test(S(), 100, 'a', S(100, 'a'));
 
     test(S("12345"), 0, 'a', S("12345"));
     test(S("12345"), 1, 'a', S("12345a"));
     test(S("12345"), 10, 'a', S("12345aaaaaaaaaa"));
 
     test(S("12345678901234567890"), 0, 'a', S("12345678901234567890"));
     test(S("12345678901234567890"), 1, 'a', S("12345678901234567890a"));
     test(S("12345678901234567890"), 10, 'a', S("12345678901234567890aaaaaaaaaa"));
-    }
 #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.modifiers/string_append/string.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 str, S expected)
 {
     s.append(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S("12345"));
     test(S("12345"), S("12345"), S("1234512345"));
     test(S("12345"), S("1234567890"), S("123451234567890"));
     test(S("12345"), S("12345678901234567890"), S("1234512345678901234567890"));
 
     test(S("1234567890"), S(), S("1234567890"));
     test(S("1234567890"), S("12345"), S("123456789012345"));
     test(S("1234567890"), S("1234567890"), S("12345678901234567890"));
     test(S("1234567890"), S("12345678901234567890"), S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), S(), S("12345678901234567890"));
     test(S("12345678901234567890"), S("12345"), S("1234567890123456789012345"));
     test(S("12345678901234567890"), S("1234567890"), S("123456789012345678901234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S("12345"));
     test(S("12345"), S("12345"), S("1234512345"));
     test(S("12345"), S("1234567890"), S("123451234567890"));
     test(S("12345"), S("12345678901234567890"), S("1234512345678901234567890"));
 
     test(S("1234567890"), S(), S("1234567890"));
     test(S("1234567890"), S("12345"), S("123456789012345"));
     test(S("1234567890"), S("1234567890"), S("12345678901234567890"));
     test(S("1234567890"), S("12345678901234567890"), S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), S(), S("12345678901234567890"));
     test(S("12345678901234567890"), S("12345"), S("1234567890123456789012345"));
     test(S("12345678901234567890"), S("1234567890"), S("123456789012345678901234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
     std::string s;
     s.append({"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.modifiers/string_append/string_size_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, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
     {
         s.append(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
else
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, S str, typename S::size_type pos, S expected)
 {
     if (pos <= str.size())
     {
         s.append(str, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
             s.append(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S(), 0, 0, S());
     test(S(), S(), 1, 0, S());
     test(S(), S("12345"), 0, 3, S("123"));
     test(S(), S("12345"), 1, 4, S("2345"));
     test(S(), S("12345"), 3, 15, S("45"));
     test(S(), S("12345"), 5, 15, S(""));
     test(S(), S("12345"), 6, 15, S("not happening"));
     test(S(), S("12345678901234567890"), 0, 0, S());
     test(S(), S("12345678901234567890"), 1, 1, S("2"));
     test(S(), S("12345678901234567890"), 2, 3, S("345"));
     test(S(), S("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), S("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), S(), 0, 0, S("12345"));
     test(S("12345"), S("12345"), 2, 2, S("1234534"));
     test(S("12345"), S("1234567890"), 0, 100, S("123451234567890"));
 
     test(S("12345678901234567890"), S(), 0, 0, S("12345678901234567890"));
     test(S("12345678901234567890"), S("12345"), 1, 3, S("12345678901234567890234"));
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), 0, 0, S());
     test(S(), S(), 1, 0, S());
     test(S(), S("12345"), 0, 3, S("123"));
     test(S(), S("12345"), 1, 4, S("2345"));
     test(S(), S("12345"), 3, 15, S("45"));
     test(S(), S("12345"), 5, 15, S(""));
     test(S(), S("12345"), 6, 15, S("not happening"));
     test(S(), S("12345678901234567890"), 0, 0, S());
     test(S(), S("12345678901234567890"), 1, 1, S("2"));
     test(S(), S("12345678901234567890"), 2, 3, S("345"));
     test(S(), S("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), S("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), S(), 0, 0, S("12345"));
     test(S("12345"), S("12345"), 2, 2, S("1234534"));
     test(S("12345"), S("1234567890"), 0, 100, S("123451234567890"));
 
     test(S("12345678901234567890"), S(), 0, 0, S("12345678901234567890"));
     test(S("12345678901234567890"), S("12345"), 1, 3, S("12345678901234567890234"));
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("123456789012345678906789012345"));
-    }
 #endif
-    {
     typedef std::string S;
     test_npos(S(), S(), 0, S());
     test_npos(S(), S(), 1, S());
     test_npos(S(), S("12345"), 0, S("12345"));
     test_npos(S(), S("12345"), 1, S("2345"));
     test_npos(S(), S("12345"), 3, S("45"));
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
-    }
 
+  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.modifiers/string_append/string_view.pass.cpp

 #include <string>
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, S expected)
 {
     s.append(sv);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(), S());
     test(S(), SV("12345"), S("12345"));
     test(S(), SV("1234567890"), S("1234567890"));
     test(S(), SV("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), SV(), S("12345"));
     test(S("12345"), SV("12345"), S("1234512345"));
     test(S("12345"), SV("1234567890"), S("123451234567890"));
     test(S("12345"), SV("12345678901234567890"), S("1234512345678901234567890"));
 
     test(S("1234567890"), SV(), S("1234567890"));
     test(S("1234567890"), SV("12345"), S("123456789012345"));
     test(S("1234567890"), SV("1234567890"), S("12345678901234567890"));
     test(S("1234567890"), SV("12345678901234567890"), S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), SV(), S("12345678901234567890"));
     test(S("12345678901234567890"), SV("12345"), S("1234567890123456789012345"));
     test(S("12345678901234567890"), SV("1234567890"), S("123456789012345678901234567890"));
     test(S("12345678901234567890"), SV("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
-    }
 #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(), S());
     test(S(), SV("12345"), S("12345"));
     test(S(), SV("1234567890"), S("1234567890"));
     test(S(), SV("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), SV(), S("12345"));
     test(S("12345"), SV("12345"), S("1234512345"));
     test(S("12345"), SV("1234567890"), S("123451234567890"));
     test(S("12345"), SV("12345678901234567890"), S("1234512345678901234567890"));
 
     test(S("1234567890"), SV(), S("1234567890"));
     test(S("1234567890"), SV("12345"), S("123456789012345"));
     test(S("1234567890"), SV("1234567890"), S("12345678901234567890"));
     test(S("1234567890"), SV("12345678901234567890"), S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), SV(), S("12345678901234567890"));
     test(S("12345678901234567890"), SV("12345"), S("1234567890123456789012345"));
     test(S("12345678901234567890"), SV("1234567890"), S("123456789012345678901234567890"));
     test(S("12345678901234567890"), SV("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
-    }
 #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.modifiers/string_assign/T_size_size.pass.cpp

else
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(), 0, 0, S());
     test(S(), SV(), 1, 0, S());
     test(S(), SV("12345"), 0, 3, S("123"));
     test(S(), SV("12345"), 1, 4, S("2345"));
     test(S(), SV("12345"), 3, 15, S("45"));
     test(S(), SV("12345"), 5, 15, S(""));
     test(S(), SV("12345"), 6, 15, S("not happening"));
     test(S(), SV("12345678901234567890"), 0, 0, S());
     test(S(), SV("12345678901234567890"), 1, 1, S("2"));
     test(S(), SV("12345678901234567890"), 2, 3, S("345"));
     test(S(), SV("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), SV("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), SV(), 0, 0, S());
     test(S("12345"), SV("12345"), 2, 2, S("34"));
     test(S("12345"), SV("1234567890"), 0, 100, S("1234567890"));
 
     test(S("12345678901234567890"), SV(), 0, 0, S());
     test(S("12345678901234567890"), SV("12345"), 1, 3, S("234"));
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("6789012345"));
-    }
 #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(), 0, 0, S());
     test(S(), SV(), 1, 0, S());
     test(S(), SV("12345"), 0, 3, S("123"));
     test(S(), SV("12345"), 1, 4, S("2345"));
     test(S(), SV("12345"), 3, 15, S("45"));
     test(S(), SV("12345"), 5, 15, S(""));
     test(S(), SV("12345"), 6, 15, S("not happening"));
     test(S(), SV("12345678901234567890"), 0, 0, S());
     test(S(), SV("12345678901234567890"), 1, 1, S("2"));
     test(S(), SV("12345678901234567890"), 2, 3, S("345"));
     test(S(), SV("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), SV("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), SV(), 0, 0, S());
     test(S("12345"), SV("12345"), 2, 2, S("34"));
     test(S("12345"), SV("1234567890"), 0, 100, S("1234567890"));
 
     test(S("12345678901234567890"), SV(), 0, 0, S());
     test(S("12345678901234567890"), SV("12345"), 1, 3, S("234"));
     test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
          S("6789012345"));
-    }
 #endif
-    {
     typedef std::string S;
     typedef std::string_view SV;
     test_npos(S(), SV(), 0, S());
     test_npos(S(), SV(), 1, S());
     test_npos(S(), SV("12345"), 0, S("12345"));
     test_npos(S(), SV("12345"), 1, S("2345"));
     test_npos(S(), SV("12345"), 3, S("45"));
     test_npos(S(), SV("12345"), 5, S(""));
     test_npos(S(), SV("12345"), 6, S("not happening"));
-    }
 
-    {
     std::string s = "ABCD";
     std::string_view sv = "EFGH";
     char arr[] = "IJKL";
 
     s.assign("CDEF", 0);    // calls assign(const char *, len)
     assert(s == "");
     s.clear();
 
#endif
 
     s.assign(arr, 0, std::string::npos);    // calls assign(string("IJKL"), pos, npos)
     assert(s == "IJKL");
     s.clear();
 
     s.assign(arr, 0);     // calls assign(const char *, len)
     assert(s == "");
     s.clear();
-    }
 
-    {
     std::string s = "ABCD";
     std::string_view sv = s;
     s.assign(sv);
     assert(s == "ABCD");
 
     sv = s;
     s.assign(sv, 0, std::string::npos);
     assert(s == "ABCD");
-    }
 
-    {
     std::string s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     std::string_view sv = s;
     s.assign(sv);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
     sv = s;
     s.assign(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
-    }
 
+  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.modifiers/string_assign/initializer_list.pass.cpp

 // basic_string& assign(initializer_list<charT> il);
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s("123");
-        s.assign({'a', 'b', 'c'});
-        assert(s == "abc");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s("123");
-        s.assign({'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.modifiers/string_assign/iterator.pass.cpp

test_exceptions(S s, It first, It last)
     // into the string must not have been invalidated.
     LIBCPP_ASSERT(s.__invariants());
     assert(s == original);
     assert(s.begin() == begin);
     assert(s.end() == end);
 }
 #endif
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s+1, S("A"));
     test(S(), s, s+10, S("ABCDEFGHIJ"));
     test(S(), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), s, s, S());
bool test() {
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
          S());
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s+1, S("A"));
     test(S(), s, s+10, S("ABCDEFGHIJ"));
     test(S(), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), s, s, S());
#if TEST_STD_VER >= 11
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
          S());
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-    }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), w, w+100);
-    }
 #endif
 
-    { // test assigning to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.assign(s_short.begin(), s_short.end());
     assert(s_short == "123/");
     s_short.assign(s_short.begin() + 2, s_short.end());
     assert(s_short == "3/");
 
     s_long.assign(s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
     s_long.assign(s_long.begin() + 30, s_long.end());
     assert(s_long == "nsectetur/");
-    }
 
-    { // test assigning a different type
     typedef std::string S;
     const uint8_t p[] = "ABCD";
 
     S s;
     s.assign(p, p + 4);
     assert(s == "ABCD");
-    }
 
-    { // regression-test assigning to self in sneaky ways
     std::string sneaky = "hello";
     sneaky.resize(sneaky.capacity(), 'x');
     std::string expected = sneaky + std::string(1, '\0');
     test(sneaky, sneaky.data(), sneaky.data() + sneaky.size() + 1, expected);
-    }
 
+  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.modifiers/string_assign/pointer.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, const typename S::value_type* str, S expected)
 {
     s.assign(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), "", S());
     test(S(), "12345", S("12345"));
     test(S(), "12345678901234567890", S("12345678901234567890"));
 
     test(S("12345"), "", S());
     test(S("12345"), "12345", S("12345"));
     test(S("12345"), "1234567890", S("1234567890"));
 
     test(S("12345678901234567890"), "", S());
     test(S("12345678901234567890"), "12345", S("12345"));
     test(S("12345678901234567890"), "12345678901234567890",
          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(), "12345", S("12345"));
     test(S(), "12345678901234567890", S("12345678901234567890"));
 
     test(S("12345"), "", S());
     test(S("12345"), "12345", S("12345"));
     test(S("12345"), "1234567890", S("1234567890"));
 
     test(S("12345678901234567890"), "", S());
     test(S("12345678901234567890"), "12345", S("12345"));
     test(S("12345678901234567890"), "12345678901234567890",
          S("12345678901234567890"));
-    }
 #endif
 
-    { // test assignment to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.assign(s_short.c_str());
     assert(s_short == "123/");
     s_short.assign(s_short.c_str() + 2);
     assert(s_short == "3/");
 
     s_long.assign(s_long.c_str() + 30);
     assert(s_long == "nsectetur/");
-    }
 
+  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.modifiers/string_assign/pointer_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, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.assign(str, n);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), "", 0, S());
     test(S(), "12345", 3, S("123"));
     test(S(), "12345", 4, S("1234"));
     test(S(), "12345678901234567890", 0, S());
     test(S(), "12345678901234567890", 1, S("1"));
     test(S(), "12345678901234567890", 3, S("123"));
     test(S(), "12345678901234567890", 20, S("12345678901234567890"));
 
     test(S("12345"), "", 0, S());
     test(S("12345"), "12345", 5, S("12345"));
     test(S("12345"), "1234567890", 10, S("1234567890"));
 
     test(S("12345678901234567890"), "", 0, S());
     test(S("12345678901234567890"), "12345", 5, S("12345"));
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("12345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", 0, S());
     test(S(), "12345", 3, S("123"));
     test(S(), "12345", 4, S("1234"));
     test(S(), "12345678901234567890", 0, S());
     test(S(), "12345678901234567890", 1, S("1"));
     test(S(), "12345678901234567890", 3, S("123"));
     test(S(), "12345678901234567890", 20, S("12345678901234567890"));
 
     test(S("12345"), "", 0, S());
     test(S("12345"), "12345", 5, S("12345"));
     test(S("12345"), "1234567890", 10, S("1234567890"));
 
     test(S("12345678901234567890"), "", 0, S());
     test(S("12345678901234567890"), "12345", 5, S("12345"));
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("12345678901234567890"));
-    }
 #endif
-    { // test assign to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.assign(s_short.data(), s_short.size());
     assert(s_short == "123/");
     s_short.assign(s_short.data() + 2, s_short.size() - 2);
     assert(s_short == "3/");
 
     s_long.assign(s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
     s_long.assign(s_long.data() + 2, 8 );
     assert(s_long == "rem ipsu");
-    }
 
+  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.modifiers/string_assign/rv_string.pass.cpp

 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.assign(std::move(str));
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S());
     test(S("12345"), S("12345"), S("12345"));
     test(S("12345"), S("1234567890"), S("1234567890"));
     test(S("12345"), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("1234567890"), S(), S());
     test(S("1234567890"), S("12345"), S("12345"));
     test(S("1234567890"), S("1234567890"), S("1234567890"));
     test(S("1234567890"), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345678901234567890"), S(), S());
     test(S("12345678901234567890"), S("12345"), S("12345"));
     test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("12345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S());
     test(S("12345"), S("12345"), S("12345"));
     test(S("12345"), S("1234567890"), S("1234567890"));
     test(S("12345"), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("1234567890"), S(), S());
     test(S("1234567890"), S("12345"), S("12345"));
     test(S("1234567890"), S("1234567890"), S("1234567890"));
     test(S("1234567890"), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345678901234567890"), S(), S());
     test(S("12345678901234567890"), S("12345"), S("12345"));
     test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          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.modifiers/string_assign/size_char.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, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.assign(n, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S(1, 'a'));
     test(S(), 10, 'a', S(10, 'a'));
     test(S(), 100, 'a', S(100, 'a'));
 
     test(S("12345"), 0, 'a', S());
     test(S("12345"), 1, 'a', S(1, 'a'));
     test(S("12345"), 10, 'a', S(10, 'a'));
 
     test(S("12345678901234567890"), 0, 'a', S());
     test(S("12345678901234567890"), 1, 'a', S(1, 'a'));
     test(S("12345678901234567890"), 10, 'a', S(10, 'a'));
-    }
 #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(1, 'a'));
     test(S(), 10, 'a', S(10, 'a'));
     test(S(), 100, 'a', S(100, 'a'));
 
     test(S("12345"), 0, 'a', S());
     test(S("12345"), 1, 'a', S(1, 'a'));
     test(S("12345"), 10, 'a', S(10, 'a'));
 
     test(S("12345678901234567890"), 0, 'a', S());
     test(S("12345678901234567890"), 1, 'a', S(1, 'a'));
     test(S("12345678901234567890"), 10, 'a', S(10, '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.modifiers/string_assign/string.pass.cpp

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.assign(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 testAlloc(S s, S str, const typename S::allocator_type& a)
 {
     s.assign(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == str);
     assert(s.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S());
     test(S("12345"), S("12345"), S("12345"));
bool test() {
     test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("12345678901234567890"));
 
     testAlloc(S(), S(), std::allocator<char>());
     testAlloc(S(), S("12345"), std::allocator<char>());
     testAlloc(S(), S("1234567890"), std::allocator<char>());
     testAlloc(S(), S("12345678901234567890"), std::allocator<char>());
-    }
 
-    { //  LWG#5579 make sure assign takes the allocators where appropriate
     typedef other_allocator<char> A;  // has POCCA --> true
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     testAlloc(S(A(5)), S(A(3)), A(3));
     testAlloc(S(A(5)), S("1"), A());
     testAlloc(S(A(5)), S("1", A(7)), A(7));
     testAlloc(S(A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7));
-    }
 
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S());
     test(S("12345"), S("12345"), S("12345"));
#if TEST_STD_VER >= 11
     test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("12345678901234567890"));
 
     testAlloc(S(), S(), min_allocator<char>());
     testAlloc(S(), S("12345"), min_allocator<char>());
     testAlloc(S(), S("1234567890"), min_allocator<char>());
     testAlloc(S(), S("12345678901234567890"), min_allocator<char>());
-    }
 #endif
 #if TEST_STD_VER > 14
-    {
     typedef std::string S;
     static_assert(noexcept(S().assign(S())), "");  // LWG#2063
-    }
 #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.modifiers/string_assign/string_size_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, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
     {
         s.assign(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
else
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, S str, typename S::size_type pos, S expected)
 {
     if (pos <= str.size())
     {
         s.assign(str, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
             s.assign(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S(), 0, 0, S());
     test(S(), S(), 1, 0, S());
     test(S(), S("12345"), 0, 3, S("123"));
     test(S(), S("12345"), 1, 4, S("2345"));
     test(S(), S("12345"), 3, 15, S("45"));
     test(S(), S("12345"), 5, 15, S(""));
     test(S(), S("12345"), 6, 15, S("not happening"));
     test(S(), S("12345678901234567890"), 0, 0, S());
     test(S(), S("12345678901234567890"), 1, 1, S("2"));
     test(S(), S("12345678901234567890"), 2, 3, S("345"));
     test(S(), S("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), S("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), S(), 0, 0, S());
     test(S("12345"), S("12345"), 2, 2, S("34"));
     test(S("12345"), S("1234567890"), 0, 100, S("1234567890"));
 
     test(S("12345678901234567890"), S(), 0, 0, S());
     test(S("12345678901234567890"), S("12345"), 1, 3, S("234"));
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("6789012345"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), 0, 0, S());
     test(S(), S(), 1, 0, S());
     test(S(), S("12345"), 0, 3, S("123"));
     test(S(), S("12345"), 1, 4, S("2345"));
     test(S(), S("12345"), 3, 15, S("45"));
     test(S(), S("12345"), 5, 15, S(""));
     test(S(), S("12345"), 6, 15, S("not happening"));
     test(S(), S("12345678901234567890"), 0, 0, S());
     test(S(), S("12345678901234567890"), 1, 1, S("2"));
     test(S(), S("12345678901234567890"), 2, 3, S("345"));
     test(S(), S("12345678901234567890"), 12, 13, S("34567890"));
     test(S(), S("12345678901234567890"), 21, 13, S("not happening"));
 
     test(S("12345"), S(), 0, 0, S());
     test(S("12345"), S("12345"), 2, 2, S("34"));
     test(S("12345"), S("1234567890"), 0, 100, S("1234567890"));
 
     test(S("12345678901234567890"), S(), 0, 0, S());
     test(S("12345678901234567890"), S("12345"), 1, 3, S("234"));
     test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
          S("6789012345"));
-    }
 #endif
-    {
     typedef std::string S;
     test_npos(S(), S(), 0, S());
     test_npos(S(), S(), 1, S());
     test_npos(S(), S("12345"), 0, S("12345"));
     test_npos(S(), S("12345"), 1, S("2345"));
     test_npos(S(), S("12345"), 3, S("45"));
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
-    }
 
+  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.modifiers/string_assign/string_view.pass.cpp

 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, S expected)
 {
     s.assign(sv);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 testAlloc(S s, SV sv, const typename S::allocator_type& a)
 {
     s.assign(sv);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == sv);
     assert(s.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(), S());
     test(S(), SV("12345"), S("12345"));
     test(S(), SV("1234567890"), S("1234567890"));
     test(S(), SV("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), SV(), S());
bool test() {
     test(S("12345678901234567890"), SV("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), SV("12345678901234567890"),
          S("12345678901234567890"));
 
     testAlloc(S(), SV(), std::allocator<char>());
     testAlloc(S(), SV("12345"), std::allocator<char>());
     testAlloc(S(), SV("1234567890"), std::allocator<char>());
     testAlloc(S(), SV("12345678901234567890"), std::allocator<char>());
-    }
 
 #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(), S());
     test(S(), SV("12345"), S("12345"));
     test(S(), SV("1234567890"), S("1234567890"));
     test(S(), SV("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), SV(), S());
#if TEST_STD_VER >= 11
     test(S("12345678901234567890"), SV("1234567890"), S("1234567890"));
     test(S("12345678901234567890"), SV("12345678901234567890"),
          S("12345678901234567890"));
 
     testAlloc(S(), SV(), min_allocator<char>());
     testAlloc(S(), SV("12345"), min_allocator<char>());
     testAlloc(S(), SV("1234567890"), min_allocator<char>());
     testAlloc(S(), SV("12345678901234567890"), min_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.modifiers/string_copy/copy.pass.cpp

else
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     char s[50];
     test(S(""), s, 0, 0);
     test(S(""), s, 0, 1);
     test(S(""), s, 1, 0);
     test(S("abcde"), s, 0, 0);
     test(S("abcde"), s, 0, 1);
     test(S("abcde"), s, 0, 2);
bool test() {
     test(S("abcdefghijklmnopqrst"), s, 10, 10);
     test(S("abcdefghijklmnopqrst"), s, 10, 11);
     test(S("abcdefghijklmnopqrst"), s, 19, 0);
     test(S("abcdefghijklmnopqrst"), s, 19, 1);
     test(S("abcdefghijklmnopqrst"), s, 19, 2);
     test(S("abcdefghijklmnopqrst"), s, 20, 0);
     test(S("abcdefghijklmnopqrst"), s, 20, 1);
     test(S("abcdefghijklmnopqrst"), s, 21, 0);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     char s[50];
     test(S(""), s, 0, 0);
     test(S(""), s, 0, 1);
     test(S(""), s, 1, 0);
     test(S("abcde"), s, 0, 0);
     test(S("abcde"), s, 0, 1);
     test(S("abcde"), s, 0, 2);
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), s, 10, 10);
     test(S("abcdefghijklmnopqrst"), s, 10, 11);
     test(S("abcdefghijklmnopqrst"), s, 19, 0);
     test(S("abcdefghijklmnopqrst"), s, 19, 1);
     test(S("abcdefghijklmnopqrst"), s, 19, 2);
     test(S("abcdefghijklmnopqrst"), s, 20, 0);
     test(S("abcdefghijklmnopqrst"), s, 20, 1);
     test(S("abcdefghijklmnopqrst"), s, 21, 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.modifiers/string_erase/iter.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, typename S::difference_type pos, S expected)
 {
     typename S::const_iterator p = s.begin() + pos;
     typename S::iterator i = s.erase(p);
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
     assert(i - s.begin() == pos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S("abcde"), 0, S("bcde"));
     test(S("abcde"), 1, S("acde"));
     test(S("abcde"), 2, S("abde"));
     test(S("abcde"), 4, S("abcd"));
     test(S("abcdefghij"), 0, S("bcdefghij"));
     test(S("abcdefghij"), 1, S("acdefghij"));
     test(S("abcdefghij"), 5, S("abcdeghij"));
     test(S("abcdefghij"), 9, S("abcdefghi"));
     test(S("abcdefghijklmnopqrst"), 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("acdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("abcde"), 0, S("bcde"));
     test(S("abcde"), 1, S("acde"));
     test(S("abcde"), 2, S("abde"));
     test(S("abcde"), 4, S("abcd"));
     test(S("abcdefghij"), 0, S("bcdefghij"));
     test(S("abcdefghij"), 1, S("acdefghij"));
     test(S("abcdefghij"), 5, S("abcdeghij"));
     test(S("abcdefghij"), 9, S("abcdefghi"));
     test(S("abcdefghijklmnopqrst"), 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("acdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
-    }
 #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.modifiers/string_erase/iter_iter.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, typename S::difference_type pos, typename S::difference_type n, S expected)
 {
     typename S::const_iterator first = s.cbegin() + pos;
     typename S::const_iterator last = s.cbegin() + pos + n;
     typename S::iterator i = s.erase(first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
     assert(i - s.begin() == pos);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 0, 0, S(""));
     test(S("abcde"), 0, 0, S("abcde"));
     test(S("abcde"), 0, 1, S("bcde"));
     test(S("abcde"), 0, 2, S("cde"));
     test(S("abcde"), 0, 4, S("e"));
     test(S("abcde"), 0, 5, S(""));
     test(S("abcde"), 1, 0, S("abcde"));
bool test() {
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 9, S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, S(""));
     test(S("abcde"), 0, 0, S("abcde"));
     test(S("abcde"), 0, 1, S("bcde"));
     test(S("abcde"), 0, 2, S("cde"));
     test(S("abcde"), 0, 4, S("e"));
     test(S("abcde"), 0, 5, S(""));
     test(S("abcde"), 1, 0, S("abcde"));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 9, S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_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, S expected)
 {
     s.pop_back();
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S("abcde"), S("abcd"));
     test(S("abcdefghij"), S("abcdefghi"));
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S("abcde"), S("abcd"));
     test(S("abcdefghij"), S("abcdefghi"));
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
-    }
 #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.modifiers/string_erase/size_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 pos, typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.erase(pos, n);
         LIBCPP_ASSERT(s.__invariants());
else
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.erase(pos);
         LIBCPP_ASSERT(s.__invariants());
else
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S expected)
 {
     s.erase();
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 0, 0, S(""));
     test(S(""), 0, 1, S(""));
     test(S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, 0, S("abcde"));
     test(S("abcde"), 0, 1, S("bcde"));
     test(S("abcde"), 0, 2, S("cde"));
     test(S("abcde"), 0, 4, S("e"));
bool test() {
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 20, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 21, S("can't happen"));
 
     test(S(""), S(""));
     test(S("abcde"), S(""));
     test(S("abcdefghij"), S(""));
     test(S("abcdefghijklmnopqrst"), S(""));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, S(""));
     test(S(""), 0, 1, S(""));
     test(S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, 0, S("abcde"));
     test(S("abcde"), 0, 1, S("bcde"));
     test(S("abcde"), 0, 2, S("cde"));
     test(S("abcde"), 0, 4, S("e"));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 20, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 21, S("can't happen"));
 
     test(S(""), S(""));
     test(S("abcde"), S(""));
     test(S("abcdefghij"), S(""));
     test(S("abcdefghijklmnopqrst"), 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.modifiers/string_insert/iter_char.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::const_iterator p, typename S::value_type c, S expected)
 {
     bool sufficient_cap = s.size() < s.capacity();
     typename S::difference_type pos = p - s.begin();
     typename S::iterator i = s.insert(p, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     assert(i - s.begin() == pos);
     assert(*i == c);
     if (sufficient_cap)
         assert(i == p);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     S s;
     test(s, s.begin(), '1', S("1"));
     test(s, s.begin(), 'a', S("a1"));
     test(s, s.end(), 'b', S("a1b"));
     test(s, s.end()-1, 'c', S("a1cb"));
     test(s, s.end()-2, 'd', S("a1dcb"));
     test(s, s.end()-3, '2', S("a12dcb"));
     test(s, s.end()-4, '3', S("a132dcb"));
     test(s, s.end()-5, '4', S("a1432dcb"));
     test(s, s.begin()+1, '5', S("a51432dcb"));
     test(s, s.begin()+2, '6', S("a561432dcb"));
     test(s, s.begin()+3, '7', S("a5671432dcb"));
     test(s, s.begin()+4, 'A', S("a567A1432dcb"));
     test(s, s.begin()+5, 'B', S("a567AB1432dcb"));
     test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     test(s, s.begin(), '1', S("1"));
     test(s, s.begin(), 'a', S("a1"));
     test(s, s.end(), 'b', S("a1b"));
     test(s, s.end()-1, 'c', S("a1cb"));
     test(s, s.end()-2, 'd', S("a1dcb"));
     test(s, s.end()-3, '2', S("a12dcb"));
     test(s, s.end()-4, '3', S("a132dcb"));
     test(s, s.end()-5, '4', S("a1432dcb"));
     test(s, s.begin()+1, '5', S("a51432dcb"));
     test(s, s.begin()+2, '6', S("a561432dcb"));
     test(s, s.begin()+3, '7', S("a5671432dcb"));
     test(s, s.begin()+4, 'A', S("a567A1432dcb"));
     test(s, s.begin()+5, 'B', S("a567AB1432dcb"));
     test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
-    }
 #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.modifiers/string_insert/iter_initializer_list.pass.cpp

 
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s("123456");
-        std::string::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
-        assert(i - s.begin() == 3);
-        assert(s == "123abc456");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s("123456");
-        S::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
-        assert(i - s.begin() == 3);
-        assert(s == "123abc456");
-    }
+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.modifiers/string_insert/iter_iter_iter.pass.cpp

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, It first, It last, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(i - s.begin() == pos);
     assert(s == expected);
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, typename S::difference_type pos, It first, It last)
 {
     typename S::const_iterator p = s.cbegin() + pos;
 
     S original = s;
     typename S::iterator begin = s.begin();
     typename S::iterator end = s.end();
 
     try {
         s.insert(p, first, last);
         assert(false);
     } catch (...) {}
 
     // Part of "no effects" is that iterators and pointers
     // into the string must not have been invalidated.
     LIBCPP_ASSERT(s.__invariants());
     assert(s == original);
     assert(s.begin() == begin);
     assert(s.end() == end);
 }
 #endif
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), 0, s, s, S());
     test(S(), 0, s, s+1, S("A"));
     test(S(), 0, s, s+10, S("ABCDEFGHIJ"));
     test(S(), 0, s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), 0, s, s, S("12345"));
bool test() {
     test(S("1234567890"), 10, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
     test(S("1234567890"), 8, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
 
     test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345678901234567890"));
     test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("123A45678901234567890"));
     test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
     test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), 0, s, s, S());
     test(S(), 0, s, s+1, S("A"));
     test(S(), 0, s, s+10, S("ABCDEFGHIJ"));
     test(S(), 0, s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), 0, s, s, S("12345"));
#if TEST_STD_VER >= 11
     test(S("1234567890"), 10, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
     test(S("1234567890"), 8, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
 
     test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345678901234567890"));
     test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("123A45678901234567890"));
     test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
     test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-    }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), 0, w, w+100);
-    }
 #endif
 
-    { // test inserting into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/");
     s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/");
     s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.insert(s_long.begin(), s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
-    { // test assigning a different type
     typedef std::string S;
     const uint8_t p[] = "ABCD";
 
     S s;
     s.insert(s.begin(), p, p + 4);
     assert(s == "ABCD");
-    }
 
-    { // regression-test inserting into self in sneaky ways
     std::string s_short = "hello";
     std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
     std::string s_othertype = "hello";
     const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
 
     test(s_short, 0, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("\0hello", 6));
     test(s_long, 0, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
          std::string("\0Lorem ipsum dolor sit amet, consectetur/", 41));
     test(s_othertype, 1, first + 2, first + 5, std::string("hlloello"));
-    }
 
   { // test with a move iterator that returns char&&
     typedef cpp17_input_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
     s.insert(s.begin(), MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
#endif
     typedef const char* It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
     s.insert(s.begin(), MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
 
+  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.modifiers/string_insert/iter_size_char.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, typename S::difference_type pos, typename S::size_type n,
      typename S::value_type c, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, n, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(i - s.begin() == pos);
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 0, 0, '1', S(""));
     test(S(""), 0, 5, '1', S("11111"));
     test(S(""), 0, 10, '1', S("1111111111"));
     test(S(""), 0, 20, '1', S("11111111111111111111"));
     test(S("abcde"), 0, 0, '1', S("abcde"));
     test(S("abcde"), 0, 5, '1', S("11111abcde"));
     test(S("abcde"), 0, 10, '1', S("1111111111abcde"));
bool test() {
     test(S("abcdefghijklmnopqrst"), 19, 0, '1', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 5, '1', S("abcdefghijklmnopqrs11111t"));
     test(S("abcdefghijklmnopqrst"), 19, 10, '1', S("abcdefghijklmnopqrs1111111111t"));
     test(S("abcdefghijklmnopqrst"), 19, 20, '1', S("abcdefghijklmnopqrs11111111111111111111t"));
     test(S("abcdefghijklmnopqrst"), 20, 0, '1', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 5, '1', S("abcdefghijklmnopqrst11111"));
     test(S("abcdefghijklmnopqrst"), 20, 10, '1', S("abcdefghijklmnopqrst1111111111"));
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, '1', S(""));
     test(S(""), 0, 5, '1', S("11111"));
     test(S(""), 0, 10, '1', S("1111111111"));
     test(S(""), 0, 20, '1', S("11111111111111111111"));
     test(S("abcde"), 0, 0, '1', S("abcde"));
     test(S("abcde"), 0, 5, '1', S("11111abcde"));
     test(S("abcde"), 0, 10, '1', S("1111111111abcde"));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 19, 0, '1', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 5, '1', S("abcdefghijklmnopqrs11111t"));
     test(S("abcdefghijklmnopqrst"), 19, 10, '1', S("abcdefghijklmnopqrs1111111111t"));
     test(S("abcdefghijklmnopqrst"), 19, 20, '1', S("abcdefghijklmnopqrs11111111111111111111t"));
     test(S("abcdefghijklmnopqrst"), 20, 0, '1', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 5, '1', S("abcdefghijklmnopqrst11111"));
     test(S("abcdefghijklmnopqrst"), 20, 10, '1', S("abcdefghijklmnopqrst1111111111"));
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
-    }
 #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.modifiers/string_insert/size_T_size_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= sv.size())
     {
else
             assert(pos1 > old_size || pos2 > sv.size());
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2, S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.insert(pos1, sv, pos2);
else
             assert(s == s0);
         }
     }
 #endif
 }
 
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, SV(""), 0, 0, S(""));
     test(S(""), 0, SV(""), 0, 1, S(""));
     test(S(""), 0, SV(""), 1, 0, S("can't happen"));
     test(S(""), 0, SV("12345"), 0, 0, S(""));
     test(S(""), 0, SV("12345"), 0, 1, S("1"));
     test(S(""), 0, SV("12345"), 0, 2, S("12"));
     test(S(""), 0, SV("12345"), 0, 4, S("1234"));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, SV("1234567890"), 5, 5, S("67890"));
     test(S(""), 0, SV("1234567890"), 5, 6, S("67890"));
     test(S(""), 0, SV("1234567890"), 9, 0, S(""));
     test(S(""), 0, SV("1234567890"), 9, 1, S("0"));
     test(S(""), 0, SV("1234567890"), 9, 2, S("0"));
     test(S(""), 0, SV("1234567890"), 10, 0, S(""));
     test(S(""), 0, SV("1234567890"), 10, 1, S(""));
     test(S(""), 0, SV("1234567890"), 11, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, SV("12345678901234567890"), 0, 0, S(""));
     test(S(""), 0, SV("12345678901234567890"), 0, 1, S("1"));
     test(S(""), 0, SV("12345678901234567890"), 0, 10, S("1234567890"));
     test(S(""), 0, SV("12345678901234567890"), 0, 19, S("1234567890123456789"));
     test(S(""), 0, SV("12345678901234567890"), 0, 20, S("12345678901234567890"));
     test(S(""), 0, SV("12345678901234567890"), 0, 21, S("12345678901234567890"));
     test(S(""), 0, SV("12345678901234567890"), 1, 0, S(""));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, SV("12345"), 2, 3, S("can't happen"));
     test(S(""), 1, SV("12345"), 2, 4, S("can't happen"));
     test(S(""), 1, SV("12345"), 4, 0, S("can't happen"));
     test(S(""), 1, SV("12345"), 4, 1, S("can't happen"));
     test(S(""), 1, SV("12345"), 4, 2, S("can't happen"));
     test(S(""), 1, SV("12345"), 5, 0, S("can't happen"));
     test(S(""), 1, SV("12345"), 5, 1, S("can't happen"));
     test(S(""), 1, SV("12345"), 6, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, SV("1234567890"), 0, 0, S("can't happen"));
     test(S(""), 1, SV("1234567890"), 0, 1, S("can't happen"));
     test(S(""), 1, SV("1234567890"), 0, 5, S("can't happen"));
     test(S(""), 1, SV("1234567890"), 0, 9, S("can't happen"));
     test(S(""), 1, SV("1234567890"), 0, 10, S("can't happen"));
     test(S(""), 1, SV("1234567890"), 0, 11, S("can't happen"));
     test(S(""), 1, SV("1234567890"), 1, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S(""), 1, SV("12345678901234567890"), 19, 0, S("can't happen"));
     test(S(""), 1, SV("12345678901234567890"), 19, 1, S("can't happen"));
     test(S(""), 1, SV("12345678901234567890"), 19, 2, S("can't happen"));
     test(S(""), 1, SV("12345678901234567890"), 20, 0, S("can't happen"));
     test(S(""), 1, SV("12345678901234567890"), 20, 1, S("can't happen"));
     test(S(""), 1, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 0, SV(""), 0, 0, S("abcde"));
     test(S("abcde"), 0, SV(""), 0, 1, S("abcde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, SV(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, SV("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 0, SV("12345"), 0, 1, S("1abcde"));
     test(S("abcde"), 0, SV("12345"), 0, 2, S("12abcde"));
     test(S("abcde"), 0, SV("12345"), 0, 4, S("1234abcde"));
     test(S("abcde"), 0, SV("12345"), 0, 5, S("12345abcde"));
     test(S("abcde"), 0, SV("12345"), 0, 6, S("12345abcde"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, SV("1234567890"), 9, 0, S("abcde"));
     test(S("abcde"), 0, SV("1234567890"), 9, 1, S("0abcde"));
     test(S("abcde"), 0, SV("1234567890"), 9, 2, S("0abcde"));
     test(S("abcde"), 0, SV("1234567890"), 10, 0, S("abcde"));
     test(S("abcde"), 0, SV("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 0, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 0, SV("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 0, SV("12345678901234567890"), 0, 1, S("1abcde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, SV("12345678901234567890"), 0, 10, S("1234567890abcde"));
     test(S("abcde"), 0, SV("12345678901234567890"), 0, 19, S("1234567890123456789abcde"));
     test(S("abcde"), 0, SV("12345678901234567890"), 0, 20, S("12345678901234567890abcde"));
     test(S("abcde"), 0, SV("12345678901234567890"), 0, 21, S("12345678901234567890abcde"));
     test(S("abcde"), 0, SV("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 0, SV("12345678901234567890"), 1, 1, S("2abcde"));
     test(S("abcde"), 0, SV("12345678901234567890"), 1, 9, S("234567890abcde"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 1, SV("12345"), 4, 0, S("abcde"));
     test(S("abcde"), 1, SV("12345"), 4, 1, S("a5bcde"));
     test(S("abcde"), 1, SV("12345"), 4, 2, S("a5bcde"));
     test(S("abcde"), 1, SV("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 1, SV("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 1, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 1, SV("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 1, SV("1234567890"), 0, 1, S("a1bcde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 1, SV("1234567890"), 0, 5, S("a12345bcde"));
     test(S("abcde"), 1, SV("1234567890"), 0, 9, S("a123456789bcde"));
     test(S("abcde"), 1, SV("1234567890"), 0, 10, S("a1234567890bcde"));
     test(S("abcde"), 1, SV("1234567890"), 0, 11, S("a1234567890bcde"));
     test(S("abcde"), 1, SV("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 1, SV("1234567890"), 1, 1, S("a2bcde"));
     test(S("abcde"), 1, SV("1234567890"), 1, 4, S("a2345bcde"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 1, SV("12345678901234567890"), 19, 2, S("a0bcde"));
     test(S("abcde"), 1, SV("12345678901234567890"), 20, 0, S("abcde"));
     test(S("abcde"), 1, SV("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 1, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 2, SV(""), 0, 0, S("abcde"));
     test(S("abcde"), 2, SV(""), 0, 1, S("abcde"));
     test(S("abcde"), 2, SV(""), 1, 0, S("can't happen"));
     test(S("abcde"), 2, SV("12345"), 0, 0, S("abcde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 2, SV("12345"), 0, 1, S("ab1cde"));
     test(S("abcde"), 2, SV("12345"), 0, 2, S("ab12cde"));
     test(S("abcde"), 2, SV("12345"), 0, 4, S("ab1234cde"));
     test(S("abcde"), 2, SV("12345"), 0, 5, S("ab12345cde"));
     test(S("abcde"), 2, SV("12345"), 0, 6, S("ab12345cde"));
     test(S("abcde"), 2, SV("12345"), 1, 0, S("abcde"));
     test(S("abcde"), 2, SV("12345"), 1, 1, S("ab2cde"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 2, SV("1234567890"), 9, 2, S("ab0cde"));
     test(S("abcde"), 2, SV("1234567890"), 10, 0, S("abcde"));
     test(S("abcde"), 2, SV("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 2, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 2, SV("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 0, 1, S("ab1cde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 0, 10, S("ab1234567890cde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 0, 19, S("ab1234567890123456789cde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 2, SV("12345678901234567890"), 0, 20, S("ab12345678901234567890cde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 0, 21, S("ab12345678901234567890cde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 1, 1, S("ab2cde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 1, 9, S("ab234567890cde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 1, 18, S("ab234567890123456789cde"));
     test(S("abcde"), 2, SV("12345678901234567890"), 1, 19, S("ab2345678901234567890cde"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 4, SV("12345"), 4, 2, S("abcd5e"));
     test(S("abcde"), 4, SV("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 4, SV("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 4, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 4, SV("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 4, SV("1234567890"), 0, 1, S("abcd1e"));
     test(S("abcde"), 4, SV("1234567890"), 0, 5, S("abcd12345e"));
     test(S("abcde"), 4, SV("1234567890"), 0, 9, S("abcd123456789e"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 4, SV("1234567890"), 0, 10, S("abcd1234567890e"));
     test(S("abcde"), 4, SV("1234567890"), 0, 11, S("abcd1234567890e"));
     test(S("abcde"), 4, SV("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 4, SV("1234567890"), 1, 1, S("abcd2e"));
     test(S("abcde"), 4, SV("1234567890"), 1, 4, S("abcd2345e"));
     test(S("abcde"), 4, SV("1234567890"), 1, 8, S("abcd23456789e"));
     test(S("abcde"), 4, SV("1234567890"), 1, 9, S("abcd234567890e"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 4, SV("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 4, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 5, SV(""), 0, 0, S("abcde"));
     test(S("abcde"), 5, SV(""), 0, 1, S("abcde"));
     test(S("abcde"), 5, SV(""), 1, 0, S("can't happen"));
     test(S("abcde"), 5, SV("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 5, SV("12345"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, SV("12345"), 0, 2, S("abcde12"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 5, SV("12345"), 0, 4, S("abcde1234"));
     test(S("abcde"), 5, SV("12345"), 0, 5, S("abcde12345"));
     test(S("abcde"), 5, SV("12345"), 0, 6, S("abcde12345"));
     test(S("abcde"), 5, SV("12345"), 1, 0, S("abcde"));
     test(S("abcde"), 5, SV("12345"), 1, 1, S("abcde2"));
     test(S("abcde"), 5, SV("12345"), 1, 2, S("abcde23"));
     test(S("abcde"), 5, SV("12345"), 1, 3, S("abcde234"));
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 5, SV("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 5, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 5, SV("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 5, SV("12345678901234567890"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, SV("12345678901234567890"), 0, 10, S("abcde1234567890"));
     test(S("abcde"), 5, SV("12345678901234567890"), 0, 19, S("abcde1234567890123456789"));
     test(S("abcde"), 5, SV("12345678901234567890"), 0, 20, S("abcde12345678901234567890"));
     test(S("abcde"), 5, SV("12345678901234567890"), 0, 21, S("abcde12345678901234567890"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 5, SV("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 5, SV("12345678901234567890"), 1, 1, S("abcde2"));
     test(S("abcde"), 5, SV("12345678901234567890"), 1, 9, S("abcde234567890"));
     test(S("abcde"), 5, SV("12345678901234567890"), 1, 18, S("abcde234567890123456789"));
     test(S("abcde"), 5, SV("12345678901234567890"), 1, 19, S("abcde2345678901234567890"));
     test(S("abcde"), 5, SV("12345678901234567890"), 1, 20, S("abcde2345678901234567890"));
     test(S("abcde"), 5, SV("12345678901234567890"), 10, 0, S("abcde"));
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 6, SV("12345"), 5, 1, S("can't happen"));
     test(S("abcde"), 6, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 0, 0, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 0, 1, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 0, 5, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 0, 9, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 0, 10, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 0, 11, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcde"), 6, SV("1234567890"), 1, 0, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 1, 1, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 1, 4, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 1, 8, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 1, 9, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 1, 10, S("can't happen"));
     test(S("abcde"), 6, SV("1234567890"), 5, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcdefghij"), 0, SV(""), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, SV(""), 0, 1, S("abcdefghij"));
     test(S("abcdefghij"), 0, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 0, SV("12345"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 0, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 0, 2, S("12abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 0, 4, S("1234abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 0, 5, S("12345abcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcdefghij"), 0, SV("12345"), 0, 6, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 1, 1, S("2abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 1, 2, S("23abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 1, 3, S("234abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 1, 4, S("2345abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345"), 1, 5, S("2345abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 0, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 0, 10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 0, 19, S("1234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 0, 20, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 0, 21, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 1, 1, S("2abcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 1, 9, S("234567890abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 1, 18, S("234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 1, 19, S("2345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 1, 20, S("2345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 10, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, SV("12345678901234567890"), 10, 5, S("12345abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcdefghij"), 1, SV("1234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 0, 1, S("a1bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 0, 5, S("a12345bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 0, 9, S("a123456789bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 0, 10, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 0, 11, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 1, 1, S("a2bcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcdefghij"), 1, SV("1234567890"), 1, 4, S("a2345bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 1, 8, S("a23456789bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 1, 9, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 1, 10, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 5, 1, S("a6bcdefghij"));
     test(S("abcdefghij"), 1, SV("1234567890"), 5, 2, S("a67bcdefghij"));
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcdefghij"), 5, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 5, SV("12345"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, SV("12345"), 0, 1, S("abcde1fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 0, 2, S("abcde12fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 0, 4, S("abcde1234fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 0, 5, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 0, 6, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 1, 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcdefghij"), 5, SV("12345"), 1, 1, S("abcde2fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 1, 2, S("abcde23fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 1, 3, S("abcde234fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 1, 4, S("abcde2345fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 1, 5, S("abcde2345fghij"));
     test(S("abcdefghij"), 5, SV("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, SV("12345"), 2, 1, S("abcde3fghij"));
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 0, 10, S("abcde1234567890fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 0, 19, S("abcde1234567890123456789fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 0, 20, S("abcde12345678901234567890fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 0, 21, S("abcde12345678901234567890fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 1, 1, S("abcde2fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 1, 9, S("abcde234567890fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 1, 18, S("abcde234567890123456789fghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 1, 19, S("abcde2345678901234567890fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 1, 20, S("abcde2345678901234567890fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 10, 1, S("abcde1fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 10, 5, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 10, 9, S("abcde123456789fghij"));
     test(S("abcdefghij"), 5, SV("12345678901234567890"), 10, 10, S("abcde1234567890fghij"));
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcdefghij"), 9, SV("1234567890"), 0, 5, S("abcdefghi12345j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 0, 9, S("abcdefghi123456789j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 0, 10, S("abcdefghi1234567890j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 0, 11, S("abcdefghi1234567890j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, SV("1234567890"), 1, 1, S("abcdefghi2j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 1, 4, S("abcdefghi2345j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 1, 8, S("abcdefghi23456789j"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcdefghij"), 9, SV("1234567890"), 1, 9, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 1, 10, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, SV("1234567890"), 5, 1, S("abcdefghi6j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 5, 2, S("abcdefghi67j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 5, 4, S("abcdefghi6789j"));
     test(S("abcdefghij"), 9, SV("1234567890"), 5, 5, S("abcdefghi67890j"));
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcdefghij"), 10, SV("12345"), 0, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, SV("12345"), 0, 2, S("abcdefghij12"));
     test(S("abcdefghij"), 10, SV("12345"), 0, 4, S("abcdefghij1234"));
     test(S("abcdefghij"), 10, SV("12345"), 0, 5, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, SV("12345"), 0, 6, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, SV("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, SV("12345"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghij"), 10, SV("12345"), 1, 2, S("abcdefghij23"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcdefghij"), 10, SV("12345"), 1, 3, S("abcdefghij234"));
     test(S("abcdefghij"), 10, SV("12345"), 1, 4, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, SV("12345"), 1, 5, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, SV("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, SV("12345"), 2, 1, S("abcdefghij3"));
     test(S("abcdefghij"), 10, SV("12345"), 2, 2, S("abcdefghij34"));
     test(S("abcdefghij"), 10, SV("12345"), 2, 3, S("abcdefghij345"));
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 0, 20, S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 0, 21, S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 1, 9, S("abcdefghij234567890"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 10, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 10, 5, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 10, 9, S("abcdefghij123456789"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 10, 10, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 10, 11, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, SV("12345678901234567890"), 19, 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 11, SV("1234567890"), 0, 10, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 0, 11, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 1, 1, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 1, 4, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 1, 8, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 1, 9, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 1, 10, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test20()
+TEST_CONSTEXPR_CXX20 bool test20()
 {
     test(S("abcdefghij"), 11, SV("1234567890"), 5, 0, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 5, 1, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 5, 2, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 5, 4, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 5, 5, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 5, 6, S("can't happen"));
     test(S("abcdefghij"), 11, SV("1234567890"), 9, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 0, 4, S("1234abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 0, 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 0, 6, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 1, 1, S("2abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 1, 2, S("23abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 1, 3, S("234abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 1, 4, S("2345abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 1, 5, S("2345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 2, 1, S("3abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 2, 2, S("34abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 2, 3, S("345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 2, 4, S("345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345"), 4, 0, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 1, 1, S("2abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 1, 9, S("234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 1, 18, S("234567890123456789abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 1, 19, S("2345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 1, 20, S("2345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 10, 1, S("1abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 10, 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 10, 9, S("123456789abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 10, 10, S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 10, 11, S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 19, 1, S("0abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), 19, 2, S("0abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 1, 1, S("a2bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 1, 4, S("a2345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 1, 8, S("a23456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 1, 9, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 1, 10, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 5, 1, S("a6bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 5, 2, S("a67bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 5, 4, S("a6789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 5, 5, S("a67890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 5, 6, S("a67890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 9, 1, S("a0bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), 9, 2, S("a0bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 0, 6, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 1, 1, S("abcdefghij2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 1, 2, S("abcdefghij23klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 1, 3, S("abcdefghij234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 1, 4, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 1, 5, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 2, 0, S("abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 2, 1, S("abcdefghij3klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 2, 2, S("abcdefghij34klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 2, 3, S("abcdefghij345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 2, 4, S("abcdefghij345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 4, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 4, 1, S("abcdefghij5klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345"), 4, 2, S("abcdefghij5klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 1, 9, S("abcdefghij234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 10, 1, S("abcdefghij1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 10, 5, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 10, 9, S("abcdefghij123456789klmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 10, 10, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 10, 11, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 19, 1, S("abcdefghij0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 19, 2, S("abcdefghij0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 1, 4, S("abcdefghijklmnopqrs2345t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 1, 8, S("abcdefghijklmnopqrs23456789t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 1, 9, S("abcdefghijklmnopqrs234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 1, 10, S("abcdefghijklmnopqrs234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 5, 1, S("abcdefghijklmnopqrs6t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 5, 2, S("abcdefghijklmnopqrs67t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 5, 4, S("abcdefghijklmnopqrs6789t"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 5, 5, S("abcdefghijklmnopqrs67890t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 5, 6, S("abcdefghijklmnopqrs67890t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 9, 1, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 9, 2, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), 10, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 1, 1, S("abcdefghijklmnopqrst2"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 1, 2, S("abcdefghijklmnopqrst23"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 1, 3, S("abcdefghijklmnopqrst234"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 1, 4, S("abcdefghijklmnopqrst2345"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 1, 5, S("abcdefghijklmnopqrst2345"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 2, 1, S("abcdefghijklmnopqrst3"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 2, 2, S("abcdefghijklmnopqrst34"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 2, 3, S("abcdefghijklmnopqrst345"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 2, 4, S("abcdefghijklmnopqrst345"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 4, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 4, 1, S("abcdefghijklmnopqrst5"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 4, 2, S("abcdefghijklmnopqrst5"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), 5, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 1, 19, S("abcdefghijklmnopqrst2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 1, 20, S("abcdefghijklmnopqrst2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 10, 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 10, 5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 10, 9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 10, 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 10, 11, S("abcdefghijklmnopqrst1234567890"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 19, 2, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV(""), 0, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 1, 9, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 1, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 5, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 5, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 5, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 5, 4, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 5, 5, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 5, 6, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test29()
+TEST_CONSTEXPR_CXX20 bool test29()
 {
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 9, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 9, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 9, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 10, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 10, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 0, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 10, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 10, 11, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 19, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 19, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 19, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 20, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 20, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), 21, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test_npos(S(""), 0, SV("12345678901234567890"),  0, S("12345678901234567890"));
     test_npos(S(""), 0, SV("12345678901234567890"),  1, S( "2345678901234567890"));
     test_npos(S(""), 0, SV("12345678901234567890"),  2, S(  "345678901234567890"));
     test_npos(S(""), 0, SV("12345678901234567890"),  3, S(   "45678901234567890"));
     test_npos(S(""), 0, SV("12345678901234567890"),  5, S(     "678901234567890"));
     test_npos(S(""), 0, SV("12345678901234567890"), 10, S(          "1234567890"));
     test_npos(S(""), 0, SV("12345678901234567890"), 21, S("can't happen"));
     test_npos(S("abcdefghijklmnopqrst"), 10, SV("12345"), 0, S("abcdefghij12345klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, SV("12345"), 1, S("abcdefghij2345klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, SV("12345"), 3, S("abcdefghij45klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, SV("12345"), 5, S("abcdefghijklmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, SV("12345"), 6, S("can't happen"));
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
-    test3<S, SV>();
-    test4<S, SV>();
-    test5<S, SV>();
-    test6<S, SV>();
-    test7<S, SV>();
-    test8<S, SV>();
-    test9<S, SV>();
-    test10<S, SV>();
-    test11<S, SV>();
-    test12<S, SV>();
-    test13<S, SV>();
-    test14<S, SV>();
-    test15<S, SV>();
-    test16<S, SV>();
-    test17<S, SV>();
-    test18<S, SV>();
-    test19<S, SV>();
-    test20<S, SV>();
-    test21<S, SV>();
-    test22<S, SV>();
-    test23<S, SV>();
-    test24<S, SV>();
-    test25<S, SV>();
-    test26<S, SV>();
-    test27<S, SV>();
-    test28<S, SV>();
-    test29<S, SV>();
-    test30<S, SV>();
-    }
-#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;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
-    test3<S, SV>();
-    test4<S, SV>();
-    test5<S, SV>();
-    test6<S, SV>();
-    test7<S, SV>();
-    test8<S, SV>();
-    test9<S, SV>();
-    test10<S, SV>();
-    test11<S, SV>();
-    test12<S, SV>();
-    test13<S, SV>();
-    test14<S, SV>();
-    test15<S, SV>();
-    test16<S, SV>();
-    test17<S, SV>();
-    test18<S, SV>();
-    test19<S, SV>();
-    test20<S, SV>();
-    test21<S, SV>();
-    test22<S, SV>();
-    test23<S, SV>();
-    test24<S, SV>();
-    test25<S, SV>();
-    test26<S, SV>();
-    test27<S, SV>();
-    test28<S, SV>();
-    test29<S, SV>();
-    test30<S, SV>();
-    }
-#endif
-    {
-    typedef std::string S;
-    typedef std::string_view SV;
-    S s;
-    SV sv = "EFGH";
-    char arr[] = "IJKL";
-
-    s.insert(0, "CDEF", 0);    // calls insert(const char *, len)
-    assert(s == "");
-    s.clear();
-
-    s.insert(0, "QRST", 0, std::string::npos); // calls insert(string("QRST"), pos, npos)
-    assert(s == "QRST");
-    s.clear();
-
-    s.insert(0, sv, 0);  // calls insert(T, pos, npos)
-    assert(s == sv);
-    s.clear();
-
-    s.insert(0, sv, 0, std::string::npos);   // calls insert(T, pos, npos)
-    assert(s == sv);
-    s.clear();
+template <class S, class SV>
+bool test31() {
+    S s;
+    SV sv = "EFGH";
+    char arr[] = "IJKL";
+
+    s.insert(0, "CDEF", 0);    // calls insert(const char *, len)
+    assert(s == "");
+    s.clear();
+
+    s.insert(0, "QRST", 0, std::string::npos); // calls insert(string("QRST"), pos, npos)
+    assert(s == "QRST");
+    s.clear();
+
+    s.insert(0, sv, 0);  // calls insert(T, pos, npos)
+    assert(s == sv);
+    s.clear();
+
+    s.insert(0, sv, 0, std::string::npos);   // calls insert(T, pos, npos)
+    assert(s == sv);
+    s.clear();
+
+    s.insert(0, arr, 0);     // calls insert(const char *, len)
+    assert(s == "");
+    s.clear();
+
+    s.insert(0, arr, 0, std::string::npos);    // calls insert(string("IJKL"), pos, npos)
+    assert(s == "IJKL");
+    s.clear();
+
+    s.insert(0, arr, 0);     // calls insert(const char *, len)
+    assert(s == "");
+    s.clear();
+
+    return true;
+
+template <class S, class SV>
+void test() {
+  test31<S, SV>();
 
-    s.insert(0, arr, 0);     // calls insert(const char *, len)
-    assert(s == "");
-    s.clear();
-
-    s.insert(0, arr, 0, std::string::npos);    // calls insert(string("IJKL"), pos, npos)
-    assert(s == "IJKL");
-    s.clear();
-
-    s.insert(0, arr, 0);     // calls insert(const char *, len)
-    assert(s == "");
-    s.clear();
-    }
+#if TEST_STD_VER > 17
+  // static_assert(test0<S, SV>());
+  // static_assert(test1<S, SV>());
+  // static_assert(test2<S, SV>());
+  // static_assert(test3<S, SV>());
+  // static_assert(test4<S, SV>());
+  // static_assert(test5<S, SV>());
+  // static_assert(test6<S, SV>());
+  // static_assert(test7<S, SV>());
+  // static_assert(test8<S, SV>());
+  // static_assert(test9<S, SV>());
+  // static_assert(test10<S, SV>());
+  // static_assert(test11<S, SV>());
+  // static_assert(test12<S, SV>());
+  // static_assert(test13<S, SV>());
+  // static_assert(test14<S, SV>());
+  // static_assert(test15<S, SV>());
+  // static_assert(test16<S, SV>());
+  // static_assert(test17<S, SV>());
+  // static_assert(test18<S, SV>());
+  // static_assert(test19<S, SV>());
+  // static_assert(test20<S, SV>());
+  // static_assert(test21<S, SV>());
+  // static_assert(test22<S, SV>());
+  // static_assert(test23<S, SV>());
+  // static_assert(test24<S, SV>());
+  // static_assert(test25<S, SV>());
+  // static_assert(test26<S, SV>());
+  // static_assert(test27<S, SV>());
+  // static_assert(test28<S, SV>());
+  // static_assert(test29<S, SV>());
+  // static_assert(test30<S, SV>());
+  // static_assert(test31<S, SV>());
+#endif
 
+int main(int, char**)
+{
+  test<std::string, std::string_view>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>,
+       std::basic_string_view<char, std::char_traits<char>>>();
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.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 pos, const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
else
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 0, "", S(""));
     test(S(""), 0, "12345", S("12345"));
     test(S(""), 0, "1234567890", S("1234567890"));
     test(S(""), 0, "12345678901234567890", S("12345678901234567890"));
     test(S(""), 1, "", S("can't happen"));
     test(S(""), 1, "12345", S("can't happen"));
     test(S(""), 1, "1234567890", S("can't happen"));
bool test() {
     test(S("abcdefghijklmnopqrst"), 20, "", S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, "12345", S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, "1234567890", S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, "", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", S("can't 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(""), 0, "12345", S("12345"));
     test(S(""), 0, "1234567890", S("1234567890"));
     test(S(""), 0, "12345678901234567890", S("12345678901234567890"));
     test(S(""), 1, "", S("can't happen"));
     test(S(""), 1, "12345", S("can't happen"));
     test(S(""), 1, "1234567890", S("can't happen"));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 20, "", S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, "12345", S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, "1234567890", S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, "", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", S("can't happen"));
-    }
 #endif
 
-    { // test inserting into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(0, s_short.c_str());
     assert(s_short == "123/123/");
     s_short.insert(0, s_short.c_str());
     assert(s_short == "123/123/123/123/");
     s_short.insert(0, s_short.c_str());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.insert(0, s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
+  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.modifiers/string_insert/size_pointer_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 pos, const typename S::value_type* str,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str, n);
else
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 0, "", 0, S(""));
     test(S(""), 0, "12345", 0, S(""));
     test(S(""), 0, "12345", 1, S("1"));
     test(S(""), 0, "12345", 2, S("12"));
     test(S(""), 0, "12345", 4, S("1234"));
     test(S(""), 0, "12345", 5, S("12345"));
     test(S(""), 0, "1234567890", 0, S(""));
bool test() {
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 5, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 9, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 20, S("can't happen"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, "", 0, S(""));
     test(S(""), 0, "12345", 0, S(""));
     test(S(""), 0, "12345", 1, S("1"));
     test(S(""), 0, "12345", 2, S("12"));
     test(S(""), 0, "12345", 4, S("1234"));
     test(S(""), 0, "12345", 5, S("12345"));
     test(S(""), 0, "1234567890", 0, S(""));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 5, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 9, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 20, S("can't happen"));
-    }
 #endif
 
-    { // test inserting into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(0, s_short.data(), s_short.size());
     assert(s_short == "123/123/");
     s_short.insert(0, s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/");
     s_short.insert(0, s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.insert(0, s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
+  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.modifiers/string_insert/size_size_char.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 pos, typename S::size_type n,
      typename S::value_type str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, n, str);
else
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 0, 0, '1', S(""));
     test(S(""), 0, 5, '1', S("11111"));
     test(S(""), 0, 10, '1', S("1111111111"));
     test(S(""), 0, 20, '1', S("11111111111111111111"));
     test(S(""), 1, 0, '1', S("can't happen"));
     test(S(""), 1, 5, '1', S("can't happen"));
     test(S(""), 1, 10, '1', S("can't happen"));
bool test() {
     test(S("abcdefghijklmnopqrst"), 20, 0, '1', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 5, '1', S("abcdefghijklmnopqrst11111"));
     test(S("abcdefghijklmnopqrst"), 20, 10, '1', S("abcdefghijklmnopqrst1111111111"));
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
     test(S("abcdefghijklmnopqrst"), 21, 0, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 5, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 10, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 20, '1', S("can't happen"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, 0, '1', S(""));
     test(S(""), 0, 5, '1', S("11111"));
     test(S(""), 0, 10, '1', S("1111111111"));
     test(S(""), 0, 20, '1', S("11111111111111111111"));
     test(S(""), 1, 0, '1', S("can't happen"));
     test(S(""), 1, 5, '1', S("can't happen"));
     test(S(""), 1, 10, '1', S("can't happen"));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 20, 0, '1', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 5, '1', S("abcdefghijklmnopqrst11111"));
     test(S("abcdefghijklmnopqrst"), 20, 10, '1', S("abcdefghijklmnopqrst1111111111"));
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
     test(S("abcdefghijklmnopqrst"), 21, 0, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 5, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 10, '1', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 20, '1', S("can't 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.modifiers/string_insert/size_string.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 pos, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
else
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(""), 0, S(""), S(""));
     test(S(""), 0, S("12345"), S("12345"));
     test(S(""), 0, S("1234567890"), S("1234567890"));
     test(S(""), 0, S("12345678901234567890"), S("12345678901234567890"));
     test(S(""), 1, S(""), S("can't happen"));
     test(S(""), 1, S("12345"), S("can't happen"));
     test(S(""), 1, S("1234567890"), S("can't happen"));
bool test() {
     test(S("abcdefghijklmnopqrst"), 20, S(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, S(""), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), S("can't happen"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(""), 0, S(""), S(""));
     test(S(""), 0, S("12345"), S("12345"));
     test(S(""), 0, S("1234567890"), S("1234567890"));
     test(S(""), 0, S("12345678901234567890"), S("12345678901234567890"));
     test(S(""), 1, S(""), S("can't happen"));
     test(S(""), 1, S("12345"), S("can't happen"));
     test(S(""), 1, S("1234567890"), S("can't happen"));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 20, S(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, S(""), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), S("can't happen"));
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
     std::string s;
     s.insert(0, {"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.modifiers/string_insert/size_string_size_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 pos1, S str, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2, n);
else
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, typename S::size_type pos1, S str, typename S::size_type pos2, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
else
             assert(s == s0);
         }
     }
 #endif
 }
 
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, S(""), 0, 0, S(""));
     test(S(""), 0, S(""), 0, 1, S(""));
     test(S(""), 0, S(""), 1, 0, S("can't happen"));
     test(S(""), 0, S("12345"), 0, 0, S(""));
     test(S(""), 0, S("12345"), 0, 1, S("1"));
     test(S(""), 0, S("12345"), 0, 2, S("12"));
     test(S(""), 0, S("12345"), 0, 4, S("1234"));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, S("1234567890"), 5, 5, S("67890"));
     test(S(""), 0, S("1234567890"), 5, 6, S("67890"));
     test(S(""), 0, S("1234567890"), 9, 0, S(""));
     test(S(""), 0, S("1234567890"), 9, 1, S("0"));
     test(S(""), 0, S("1234567890"), 9, 2, S("0"));
     test(S(""), 0, S("1234567890"), 10, 0, S(""));
     test(S(""), 0, S("1234567890"), 10, 1, S(""));
     test(S(""), 0, S("1234567890"), 11, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, S("12345678901234567890"), 0, 0, S(""));
     test(S(""), 0, S("12345678901234567890"), 0, 1, S("1"));
     test(S(""), 0, S("12345678901234567890"), 0, 10, S("1234567890"));
     test(S(""), 0, S("12345678901234567890"), 0, 19, S("1234567890123456789"));
     test(S(""), 0, S("12345678901234567890"), 0, 20, S("12345678901234567890"));
     test(S(""), 0, S("12345678901234567890"), 0, 21, S("12345678901234567890"));
     test(S(""), 0, S("12345678901234567890"), 1, 0, S(""));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, S("12345"), 2, 3, S("can't happen"));
     test(S(""), 1, S("12345"), 2, 4, S("can't happen"));
     test(S(""), 1, S("12345"), 4, 0, S("can't happen"));
     test(S(""), 1, S("12345"), 4, 1, S("can't happen"));
     test(S(""), 1, S("12345"), 4, 2, S("can't happen"));
     test(S(""), 1, S("12345"), 5, 0, S("can't happen"));
     test(S(""), 1, S("12345"), 5, 1, S("can't happen"));
     test(S(""), 1, S("12345"), 6, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, S("1234567890"), 0, 0, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 1, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 5, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 9, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 10, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 11, S("can't happen"));
     test(S(""), 1, S("1234567890"), 1, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S(""), 1, S("12345678901234567890"), 19, 0, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 19, 1, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 19, 2, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 20, 0, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 20, 1, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 0, S(""), 0, 0, S("abcde"));
     test(S("abcde"), 0, S(""), 0, 1, S("abcde"));
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, S("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 0, S("12345"), 0, 1, S("1abcde"));
     test(S("abcde"), 0, S("12345"), 0, 2, S("12abcde"));
     test(S("abcde"), 0, S("12345"), 0, 4, S("1234abcde"));
     test(S("abcde"), 0, S("12345"), 0, 5, S("12345abcde"));
     test(S("abcde"), 0, S("12345"), 0, 6, S("12345abcde"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, S("1234567890"), 9, 0, S("abcde"));
     test(S("abcde"), 0, S("1234567890"), 9, 1, S("0abcde"));
     test(S("abcde"), 0, S("1234567890"), 9, 2, S("0abcde"));
     test(S("abcde"), 0, S("1234567890"), 10, 0, S("abcde"));
     test(S("abcde"), 0, S("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 0, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 1, S("1abcde"));
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, S("12345678901234567890"), 0, 10, S("1234567890abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 19, S("1234567890123456789abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 20, S("12345678901234567890abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 21, S("12345678901234567890abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 1, 1, S("2abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 1, 9, S("234567890abcde"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 1, S("12345"), 4, 0, S("abcde"));
     test(S("abcde"), 1, S("12345"), 4, 1, S("a5bcde"));
     test(S("abcde"), 1, S("12345"), 4, 2, S("a5bcde"));
     test(S("abcde"), 1, S("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 1, S("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 1, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 1, S("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 1, S("a1bcde"));
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 1, S("1234567890"), 0, 5, S("a12345bcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 9, S("a123456789bcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 10, S("a1234567890bcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 11, S("a1234567890bcde"));
     test(S("abcde"), 1, S("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 1, S("1234567890"), 1, 1, S("a2bcde"));
     test(S("abcde"), 1, S("1234567890"), 1, 4, S("a2345bcde"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 1, S("12345678901234567890"), 19, 2, S("a0bcde"));
     test(S("abcde"), 1, S("12345678901234567890"), 20, 0, S("abcde"));
     test(S("abcde"), 1, S("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 1, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 2, S(""), 0, 0, S("abcde"));
     test(S("abcde"), 2, S(""), 0, 1, S("abcde"));
     test(S("abcde"), 2, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 2, S("12345"), 0, 0, S("abcde"));
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 2, S("12345"), 0, 1, S("ab1cde"));
     test(S("abcde"), 2, S("12345"), 0, 2, S("ab12cde"));
     test(S("abcde"), 2, S("12345"), 0, 4, S("ab1234cde"));
     test(S("abcde"), 2, S("12345"), 0, 5, S("ab12345cde"));
     test(S("abcde"), 2, S("12345"), 0, 6, S("ab12345cde"));
     test(S("abcde"), 2, S("12345"), 1, 0, S("abcde"));
     test(S("abcde"), 2, S("12345"), 1, 1, S("ab2cde"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 2, S("1234567890"), 9, 2, S("ab0cde"));
     test(S("abcde"), 2, S("1234567890"), 10, 0, S("abcde"));
     test(S("abcde"), 2, S("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 2, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 1, S("ab1cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 10, S("ab1234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 19, S("ab1234567890123456789cde"));
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 2, S("12345678901234567890"), 0, 20, S("ab12345678901234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 21, S("ab12345678901234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 1, S("ab2cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 9, S("ab234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 18, S("ab234567890123456789cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 19, S("ab2345678901234567890cde"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 4, S("12345"), 4, 2, S("abcd5e"));
     test(S("abcde"), 4, S("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 4, S("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 4, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 4, S("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 4, S("1234567890"), 0, 1, S("abcd1e"));
     test(S("abcde"), 4, S("1234567890"), 0, 5, S("abcd12345e"));
     test(S("abcde"), 4, S("1234567890"), 0, 9, S("abcd123456789e"));
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 4, S("1234567890"), 0, 10, S("abcd1234567890e"));
     test(S("abcde"), 4, S("1234567890"), 0, 11, S("abcd1234567890e"));
     test(S("abcde"), 4, S("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 4, S("1234567890"), 1, 1, S("abcd2e"));
     test(S("abcde"), 4, S("1234567890"), 1, 4, S("abcd2345e"));
     test(S("abcde"), 4, S("1234567890"), 1, 8, S("abcd23456789e"));
     test(S("abcde"), 4, S("1234567890"), 1, 9, S("abcd234567890e"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 4, S("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 4, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 5, S(""), 0, 0, S("abcde"));
     test(S("abcde"), 5, S(""), 0, 1, S("abcde"));
     test(S("abcde"), 5, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 5, S("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 5, S("12345"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, S("12345"), 0, 2, S("abcde12"));
+
+    return true;
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 5, S("12345"), 0, 4, S("abcde1234"));
     test(S("abcde"), 5, S("12345"), 0, 5, S("abcde12345"));
     test(S("abcde"), 5, S("12345"), 0, 6, S("abcde12345"));
     test(S("abcde"), 5, S("12345"), 1, 0, S("abcde"));
     test(S("abcde"), 5, S("12345"), 1, 1, S("abcde2"));
     test(S("abcde"), 5, S("12345"), 1, 2, S("abcde23"));
     test(S("abcde"), 5, S("12345"), 1, 3, S("abcde234"));
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 5, S("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 5, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 10, S("abcde1234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 19, S("abcde1234567890123456789"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 20, S("abcde12345678901234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 21, S("abcde12345678901234567890"));
+
+    return true;
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 5, S("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 1, S("abcde2"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 9, S("abcde234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 18, S("abcde234567890123456789"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 19, S("abcde2345678901234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 20, S("abcde2345678901234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 10, 0, S("abcde"));
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 6, S("12345"), 5, 1, S("can't happen"));
     test(S("abcde"), 6, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 0, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 1, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 5, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 9, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 10, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 11, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcde"), 6, S("1234567890"), 1, 0, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 1, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 4, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 8, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 9, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 10, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 5, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcdefghij"), 0, S(""), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S(""), 0, 1, S("abcdefghij"));
     test(S("abcdefghij"), 0, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 0, S("12345"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 2, S("12abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 4, S("1234abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 5, S("12345abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcdefghij"), 0, S("12345"), 0, 6, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 1, S("2abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 2, S("23abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 3, S("234abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 4, S("2345abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 5, S("2345abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 19, S("1234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 20, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 21, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 1, S("2abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 9, S("234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 18, S("234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 19, S("2345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 20, S("2345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 10, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 10, 5, S("12345abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcdefghij"), 1, S("1234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 1, S("a1bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 5, S("a12345bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 9, S("a123456789bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 10, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 11, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 1, S("a2bcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcdefghij"), 1, S("1234567890"), 1, 4, S("a2345bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 8, S("a23456789bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 9, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 10, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 5, 1, S("a6bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 5, 2, S("a67bcdefghij"));
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcdefghij"), 5, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 5, S("12345"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 1, S("abcde1fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 2, S("abcde12fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 4, S("abcde1234fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 5, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 6, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcdefghij"), 5, S("12345"), 1, 1, S("abcde2fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 2, S("abcde23fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 3, S("abcde234fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 4, S("abcde2345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 5, S("abcde2345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345"), 2, 1, S("abcde3fghij"));
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 10, S("abcde1234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 19, S("abcde1234567890123456789fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 20, S("abcde12345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 21, S("abcde12345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 1, S("abcde2fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 9, S("abcde234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 18, S("abcde234567890123456789fghij"));
+
+    return true;
 }
 
 template <class S>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 19, S("abcde2345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 20, S("abcde2345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 1, S("abcde1fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 5, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 9, S("abcde123456789fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 10, S("abcde1234567890fghij"));
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcdefghij"), 9, S("1234567890"), 0, 5, S("abcdefghi12345j"));
     test(S("abcdefghij"), 9, S("1234567890"), 0, 9, S("abcdefghi123456789j"));
     test(S("abcdefghij"), 9, S("1234567890"), 0, 10, S("abcdefghi1234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 0, 11, S("abcdefghi1234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 1, S("abcdefghi2j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 4, S("abcdefghi2345j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 8, S("abcdefghi23456789j"));
+
+    return true;
 }
 
 template <class S>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcdefghij"), 9, S("1234567890"), 1, 9, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 10, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 1, S("abcdefghi6j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 2, S("abcdefghi67j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 4, S("abcdefghi6789j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 5, S("abcdefghi67890j"));
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcdefghij"), 10, S("12345"), 0, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, S("12345"), 0, 2, S("abcdefghij12"));
     test(S("abcdefghij"), 10, S("12345"), 0, 4, S("abcdefghij1234"));
     test(S("abcdefghij"), 10, S("12345"), 0, 5, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, S("12345"), 0, 6, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, S("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghij"), 10, S("12345"), 1, 2, S("abcdefghij23"));
+
+    return true;
 }
 
 template <class S>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcdefghij"), 10, S("12345"), 1, 3, S("abcdefghij234"));
     test(S("abcdefghij"), 10, S("12345"), 1, 4, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, S("12345"), 1, 5, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, S("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345"), 2, 1, S("abcdefghij3"));
     test(S("abcdefghij"), 10, S("12345"), 2, 2, S("abcdefghij34"));
     test(S("abcdefghij"), 10, S("12345"), 2, 3, S("abcdefghij345"));
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcdefghij"), 10, S("12345678901234567890"), 0, 20, S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 0, 21, S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 9, S("abcdefghij234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890"));
+
+    return true;
 }
 
 template <class S>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 5, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 9, S("abcdefghij123456789"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 10, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 11, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 19, 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 11, S("1234567890"), 0, 10, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 0, 11, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 1, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 4, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 8, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 9, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 10, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test20()
+TEST_CONSTEXPR_CXX20 bool test20()
 {
     test(S("abcdefghij"), 11, S("1234567890"), 5, 0, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 1, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 2, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 4, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 5, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 6, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 9, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 0, 4, S("1234abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 0, 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 0, 6, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 1, S("2abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 2, S("23abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 3, S("234abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 4, S("2345abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 5, S("2345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 1, S("3abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 2, S("34abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 3, S("345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 4, S("345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 4, 0, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 1, S("2abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 9, S("234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 18, S("234567890123456789abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 19, S("2345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 20, S("2345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 1, S("1abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 9, S("123456789abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 10, S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 11, S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 19, 1, S("0abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 19, 2, S("0abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 1, S("a2bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 4, S("a2345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 8, S("a23456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 9, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 10, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 1, S("a6bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 2, S("a67bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 4, S("a6789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 5, S("a67890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 6, S("a67890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 9, 1, S("a0bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 9, 2, S("a0bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 0, 6, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 1, S("abcdefghij2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 2, S("abcdefghij23klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 3, S("abcdefghij234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 4, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 5, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 1, S("abcdefghij3klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 2, S("abcdefghij34klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 3, S("abcdefghij345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 4, S("abcdefghij345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 4, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 4, 1, S("abcdefghij5klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 4, 2, S("abcdefghij5klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 9, S("abcdefghij234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 1, S("abcdefghij1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 5, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 9, S("abcdefghij123456789klmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 10, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 11, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 19, 1, S("abcdefghij0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 19, 2, S("abcdefghij0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 4, S("abcdefghijklmnopqrs2345t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 8, S("abcdefghijklmnopqrs23456789t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 9, S("abcdefghijklmnopqrs234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 10, S("abcdefghijklmnopqrs234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 1, S("abcdefghijklmnopqrs6t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 2, S("abcdefghijklmnopqrs67t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 4, S("abcdefghijklmnopqrs6789t"));
+
+    return true;
 }
 
 template <class S>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 5, S("abcdefghijklmnopqrs67890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 6, S("abcdefghijklmnopqrs67890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 9, 1, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 9, 2, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 10, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 1, S("abcdefghijklmnopqrst2"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 2, S("abcdefghijklmnopqrst23"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 3, S("abcdefghijklmnopqrst234"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 4, S("abcdefghijklmnopqrst2345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 5, S("abcdefghijklmnopqrst2345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 1, S("abcdefghijklmnopqrst3"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 2, S("abcdefghijklmnopqrst34"));
+
+    return true;
 }
 
 template <class S>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 3, S("abcdefghijklmnopqrst345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 4, S("abcdefghijklmnopqrst345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 4, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 4, 1, S("abcdefghijklmnopqrst5"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 4, 2, S("abcdefghijklmnopqrst5"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 5, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 1, 19, S("abcdefghijklmnopqrst2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 1, 20, S("abcdefghijklmnopqrst2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 11, S("abcdefghijklmnopqrst1234567890"));
+
+    return true;
 }
 
 template <class S>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 2, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S(""), 0, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 1, 9, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 1, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 4, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 5, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 6, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test29()
+TEST_CONSTEXPR_CXX20 bool test29()
 {
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 9, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 9, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 9, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 10, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 10, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 0, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 10, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 10, 11, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 19, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 19, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 19, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 20, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 20, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 21, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test_npos(S(""), 0, S("12345678901234567890"),  0, S("12345678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  1, S( "2345678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  2, S(  "345678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  3, S(   "45678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  5, S(     "678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"), 10, S(          "1234567890"));
     test_npos(S(""), 0, S("12345678901234567890"), 21, S("can't happen"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 0, S("abcdefghij12345klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, S("abcdefghij2345klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 3, S("abcdefghij45klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 5, S("abcdefghijklmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 6, S("can't happen"));
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    test12<S>();
-    test13<S>();
-    test14<S>();
-    test15<S>();
-    test16<S>();
-    test17<S>();
-    test18<S>();
-    test19<S>();
-    test20<S>();
-    test21<S>();
-    test22<S>();
-    test23<S>();
-    test24<S>();
-    test25<S>();
-    test26<S>();
-    test27<S>();
-    test28<S>();
-    test29<S>();
-    test30<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    test12<S>();
-    test13<S>();
-    test14<S>();
-    test15<S>();
-    test16<S>();
-    test17<S>();
-    test18<S>();
-    test19<S>();
-    test20<S>();
-    test21<S>();
-    test22<S>();
-    test23<S>();
-    test24<S>();
-    test25<S>();
-    test26<S>();
-    test27<S>();
-    test28<S>();
-    test29<S>();
-    test30<S>();
-    }
+template <class S>
+void test() {
+
+#if TEST_STD_VER > 17
+  // static_assert(test0<S>());
+  // static_assert(test1<S>());
+  // static_assert(test2<S>());
+  // static_assert(test3<S>());
+  // static_assert(test4<S>());
+  // static_assert(test5<S>());
+  // static_assert(test6<S>());
+  // static_assert(test7<S>());
+  // static_assert(test8<S>());
+  // static_assert(test9<S>());
+  // static_assert(test10<S>());
+  // static_assert(test11<S>());
+  // static_assert(test12<S>());
+  // static_assert(test13<S>());
+  // static_assert(test14<S>());
+  // static_assert(test15<S>());
+  // static_assert(test16<S>());
+  // static_assert(test17<S>());
+  // static_assert(test18<S>());
+  // static_assert(test19<S>());
+  // static_assert(test20<S>());
+  // static_assert(test21<S>());
+  // static_assert(test22<S>());
+  // static_assert(test23<S>());
+  // static_assert(test24<S>());
+  // static_assert(test25<S>());
+  // static_assert(test26<S>());
+  // static_assert(test27<S>());
+  // static_assert(test28<S>());
+  // static_assert(test29<S>());
+  // static_assert(test30<S>());
+#endif
+
+int main(int, char**)
+  test<std::string>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, sv);
         LIBCPP_ASSERT(s.__invariants());
else
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(""), 0, SV(""), S(""));
     test(S(""), 0, SV("12345"), S("12345"));
     test(S(""), 0, SV("1234567890"), S("1234567890"));
     test(S(""), 0, SV("12345678901234567890"), S("12345678901234567890"));
     test(S(""), 1, SV(""), S("can't happen"));
     test(S(""), 1, SV("12345"), S("can't happen"));
bool test() {
     test(S("abcdefghijklmnopqrst"), 20, SV(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, SV(""), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
-    }
 #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(""), 0, SV(""), S(""));
     test(S(""), 0, SV("12345"), S("12345"));
     test(S(""), 0, SV("1234567890"), S("1234567890"));
     test(S(""), 0, SV("12345678901234567890"), S("12345678901234567890"));
     test(S(""), 1, SV(""), S("can't happen"));
     test(S(""), 1, SV("12345"), S("can't happen"));
#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 20, SV(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345"), S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, SV(""), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
-    }
 #endif
 
-    { // test inserting into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(0, s_short.c_str());
     assert(s_short == "123/123/");
     s_short.insert(0, s_short.c_str());
     assert(s_short == "123/123/123/123/");
     s_short.insert(0, s_short.c_str());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.insert(0, s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
+  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.modifiers/string_op_plus_equal/char.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, typename S::value_type str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), 'a', S("a"));
     test(S("12345"), 'a', S("12345a"));
     test(S("1234567890"), 'a', S("1234567890a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), 'a', S("a"));
     test(S("12345"), 'a', S("12345a"));
     test(S("1234567890"), 'a', S("1234567890a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-    }
 #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.modifiers/string_op_plus_equal/initializer_list.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("123");
-        s += {'a', 'b', 'c'};
-        assert(s == "123abc");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s("123");
-        s += {'a', 'b', 'c'};
-        assert(s == "123abc");
-    }
+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.modifiers/string_op_plus_equal/pointer.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 typename S::value_type* str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), "", S());
     test(S(), "12345", S("12345"));
     test(S(), "1234567890", S("1234567890"));
     test(S(), "12345678901234567890", S("12345678901234567890"));
 
     test(S("12345"), "", S("12345"));
     test(S("12345"), "12345", S("1234512345"));
     test(S("12345"), "1234567890", S("123451234567890"));
     test(S("12345"), "12345678901234567890", S("1234512345678901234567890"));
 
     test(S("1234567890"), "", S("1234567890"));
     test(S("1234567890"), "12345", S("123456789012345"));
     test(S("1234567890"), "1234567890", S("12345678901234567890"));
     test(S("1234567890"), "12345678901234567890", S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), "", S("12345678901234567890"));
     test(S("12345678901234567890"), "12345", S("1234567890123456789012345"));
     test(S("12345678901234567890"), "1234567890", S("123456789012345678901234567890"));
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), "", S());
     test(S(), "12345", S("12345"));
     test(S(), "1234567890", S("1234567890"));
     test(S(), "12345678901234567890", S("12345678901234567890"));
 
     test(S("12345"), "", S("12345"));
     test(S("12345"), "12345", S("1234512345"));
     test(S("12345"), "1234567890", S("123451234567890"));
     test(S("12345"), "12345678901234567890", S("1234512345678901234567890"));
 
     test(S("1234567890"), "", S("1234567890"));
     test(S("1234567890"), "12345", S("123456789012345"));
     test(S("1234567890"), "1234567890", S("12345678901234567890"));
     test(S("1234567890"), "12345678901234567890", S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), "", S("12345678901234567890"));
     test(S("12345678901234567890"), "12345", S("1234567890123456789012345"));
     test(S("12345678901234567890"), "1234567890", S("123456789012345678901234567890"));
     test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
-    }
 #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.modifiers/string_op_plus_equal/string.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 str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S("12345"));
     test(S("12345"), S("12345"), S("1234512345"));
     test(S("12345"), S("1234567890"), S("123451234567890"));
     test(S("12345"), S("12345678901234567890"), S("1234512345678901234567890"));
 
     test(S("1234567890"), S(), S("1234567890"));
     test(S("1234567890"), S("12345"), S("123456789012345"));
     test(S("1234567890"), S("1234567890"), S("12345678901234567890"));
     test(S("1234567890"), S("12345678901234567890"), S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), S(), S("12345678901234567890"));
     test(S("12345678901234567890"), S("12345"), S("1234567890123456789012345"));
     test(S("12345678901234567890"), S("1234567890"), S("123456789012345678901234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
     test(S(), S("12345678901234567890"), S("12345678901234567890"));
 
     test(S("12345"), S(), S("12345"));
     test(S("12345"), S("12345"), S("1234512345"));
     test(S("12345"), S("1234567890"), S("123451234567890"));
     test(S("12345"), S("12345678901234567890"), S("1234512345678901234567890"));
 
     test(S("1234567890"), S(), S("1234567890"));
     test(S("1234567890"), S("12345"), S("123456789012345"));
     test(S("1234567890"), S("1234567890"), S("12345678901234567890"));
     test(S("1234567890"), S("12345678901234567890"), S("123456789012345678901234567890"));
 
     test(S("12345678901234567890"), S(), S("12345678901234567890"));
     test(S("12345678901234567890"), S("12345"), S("1234567890123456789012345"));
     test(S("12345678901234567890"), S("1234567890"), S("123456789012345678901234567890"));
     test(S("12345678901234567890"), S("12345678901234567890"),
          S("1234567890123456789012345678901234567890"));
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
+  { // LWG 2946
     std::string s;
     s += {"abc", 1};
     assert(s.size() == 1);
     assert(s == "a");
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp

 // basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s("123def456");
-        s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
-        assert(s == "123abc456");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s("123def456");
-        s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
-        assert(s == "123abc456");
-    }
+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.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_iterators.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, f, l);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = std::distance(f, l);
     assert(s.size() == old_size - xlen + rlen);
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l)
 {
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
 
     S original = s;
     typename S::iterator begin = s.begin();
     typename S::iterator end = s.end();
test_exceptions(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l)
     assert(s.begin() == begin);
     assert(s.end() == end);
 }
 #endif
 
 const char* str = "12345678901234567890";
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, str, str+0, S(""));
     test(S(""), 0, 0, str, str+0, S(""));
     test(S(""), 0, 0, str, str+1, S("1"));
     test(S(""), 0, 0, str, str+2, S("12"));
     test(S(""), 0, 0, str, str+4, S("1234"));
     test(S(""), 0, 0, str, str+5, S("12345"));
     test(S(""), 0, 0, str, str+0, S(""));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S("abcde"), 0, 5, str, str+1, S("1"));
     test(S("abcde"), 0, 5, str, str+10, S("1234567890"));
     test(S("abcde"), 0, 5, str, str+19, S("1234567890123456789"));
     test(S("abcde"), 0, 5, str, str+20, S("12345678901234567890"));
     test(S("abcde"), 1, 0, str, str+0, S("abcde"));
     test(S("abcde"), 1, 0, str, str+0, S("abcde"));
     test(S("abcde"), 1, 0, str, str+1, S("a1bcde"));
     test(S("abcde"), 1, 0, str, str+2, S("a12bcde"));
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S("abcde"), 1, 0, str, str+4, S("a1234bcde"));
     test(S("abcde"), 1, 0, str, str+5, S("a12345bcde"));
     test(S("abcde"), 1, 0, str, str+0, S("abcde"));
     test(S("abcde"), 1, 0, str, str+1, S("a1bcde"));
     test(S("abcde"), 1, 0, str, str+5, S("a12345bcde"));
     test(S("abcde"), 1, 0, str, str+9, S("a123456789bcde"));
     test(S("abcde"), 1, 0, str, str+10, S("a1234567890bcde"));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S("abcde"), 2, 1, str, str+0, S("abde"));
     test(S("abcde"), 2, 1, str, str+0, S("abde"));
     test(S("abcde"), 2, 1, str, str+1, S("ab1de"));
     test(S("abcde"), 2, 1, str, str+2, S("ab12de"));
     test(S("abcde"), 2, 1, str, str+4, S("ab1234de"));
     test(S("abcde"), 2, 1, str, str+5, S("ab12345de"));
     test(S("abcde"), 2, 1, str, str+0, S("abde"));
     test(S("abcde"), 2, 1, str, str+1, S("ab1de"));
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S("abcde"), 2, 1, str, str+5, S("ab12345de"));
     test(S("abcde"), 2, 1, str, str+9, S("ab123456789de"));
     test(S("abcde"), 2, 1, str, str+10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, str, str+0, S("abde"));
     test(S("abcde"), 2, 1, str, str+1, S("ab1de"));
     test(S("abcde"), 2, 1, str, str+10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, str, str+19, S("ab1234567890123456789de"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcdefghij"), 0, 0, str, str+4, S("1234abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+5, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+0, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+5, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+9, S("123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcdefghij"), 0, 0, str, str+1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+19, S("1234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+20, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, 1, str, str+0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, str, str+0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, str, str+1, S("1bcdefghij"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcdefghij"), 1, 1, str, str+5, S("a12345cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+9, S("a123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+19, S("a1234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+20, S("a12345678901234567890cdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcdefghij"), 1, 4, str, str+0, S("afghij"));
     test(S("abcdefghij"), 1, 4, str, str+0, S("afghij"));
     test(S("abcdefghij"), 1, 4, str, str+1, S("a1fghij"));
     test(S("abcdefghij"), 1, 4, str, str+2, S("a12fghij"));
     test(S("abcdefghij"), 1, 4, str, str+4, S("a1234fghij"));
     test(S("abcdefghij"), 1, 4, str, str+5, S("a12345fghij"));
     test(S("abcdefghij"), 1, 4, str, str+0, S("afghij"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcdefghij"), 5, 2, str, str+1, S("abcde1hij"));
     test(S("abcdefghij"), 5, 2, str, str+10, S("abcde1234567890hij"));
     test(S("abcdefghij"), 5, 2, str, str+19, S("abcde1234567890123456789hij"));
     test(S("abcdefghij"), 5, 2, str, str+20, S("abcde12345678901234567890hij"));
     test(S("abcdefghij"), 5, 4, str, str+0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, str, str+0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, str, str+1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, str, str+2, S("abcde12j"));
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcdefghij"), 5, 4, str, str+4, S("abcde1234j"));
     test(S("abcdefghij"), 5, 4, str, str+5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, str, str+0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, str, str+1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, str, str+5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, str, str+9, S("abcde123456789j"));
     test(S("abcdefghij"), 5, 4, str, str+10, S("abcde1234567890j"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+2, S("12bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+4, S("1234bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+1, S("1bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+9, S("123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+19, S("1234567890123456789bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+4, S("a1234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+5, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+5, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+9, S("a123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+10, S("a1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+0, S("aklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+10, S("a1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+19, S("a1234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+20, S("a12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 18, str, str+0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, str, str+0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, str, str+1, S("a1t"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+5, S("abcdefghij12345t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+9, S("abcdefghij123456789t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+10, S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+0, S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+1, S("abcdefghij1t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+10, S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+19, S("abcdefghij1234567890123456789t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+20, S("abcdefghij12345678901234567890t"));
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+1, S("abcdefghij1"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+2, S("abcdefghij12"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+4, S("abcdefghij1234"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+5, S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+19, S("abcdefghijklmnopqrst1234567890123456789"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+20, S("abcdefghijklmnopqrst12345678901234567890"));
-}
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    }
-#endif
+    return true;
+
+template <class S>
+bool test9() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
-    typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, w, w+100);
-    }
 #endif
 
-    { // test replacing into self
-    typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/");
     s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/");
     s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.replace(s_long.begin(), s_long.begin(), s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
-    { // test assigning a different type
-    typedef std::string S;
     const uint8_t pc[] = "ABCD";
     uint8_t        p[] = "EFGH";
 
     S s;
     s.replace(s.begin(), s.end(), pc, pc + 4);
     assert(s == "ABCD");
 
     s.clear();
     s.replace(s.begin(), s.end(), p, p + 4);
     assert(s == "EFGH");
-    }
 
+  return true;
+}
+
+template <class S>
+void test() {
+  test0<S>();
+  test1<S>();
+  test2<S>();
+  test3<S>();
+  test4<S>();
+  test5<S>();
+  test6<S>();
+  test7<S>();
+  test8<S>();
+  test9<S>();
+
+#if TEST_STD_VER > 17
+  // static_assert(test0<S>());
+  // static_assert(test1<S>());
+  // static_assert(test2<S>());
+  // static_assert(test3<S>());
+  // static_assert(test4<S>());
+  // static_assert(test5<S>());
+  // static_assert(test6<S>());
+  // static_assert(test7<S>());
+  // static_assert(test8<S>());
+  // static_assert(test9<S>());
+#endif
+}
+
+int main(int, char**)
+{
+  test<std::string>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp

 #include <string>
 #include <algorithm>
 #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 pos1, typename S::size_type n1, const typename S::value_type* str, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = S::traits_type::length(str);
     assert(s.size() == old_size - xlen + rlen);
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, "", S(""));
     test(S(""), 0, 0, "12345", S("12345"));
     test(S(""), 0, 0, "1234567890", S("1234567890"));
     test(S(""), 0, 0, "12345678901234567890", S("12345678901234567890"));
     test(S("abcde"), 0, 0, "", S("abcde"));
     test(S("abcde"), 0, 0, "12345", S("12345abcde"));
     test(S("abcde"), 0, 0, "1234567890", S("1234567890abcde"));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdefghij"), 1, 0, "12345678901234567890", S("a12345678901234567890bcdefghij"));
     test(S("abcdefghij"), 1, 1, "", S("acdefghij"));
     test(S("abcdefghij"), 1, 1, "12345", S("a12345cdefghij"));
     test(S("abcdefghij"), 1, 1, "1234567890", S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", S("a12345678901234567890cdefghij"));
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcdefghij"), 1, 4, "", S("afghij"));
     test(S("abcdefghij"), 1, 4, "12345", S("a12345fghij"));
     test(S("abcdefghij"), 1, 4, "1234567890", S("a1234567890fghij"));
     test(S("abcdefghij"), 1, 4, "12345678901234567890", S("a12345678901234567890fghij"));
     test(S("abcdefghij"), 1, 8, "", S("aj"));
     test(S("abcdefghij"), 1, 8, "12345", S("a12345j"));
     test(S("abcdefghij"), 1, 8, "1234567890", S("a1234567890j"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghijklmnopqrst"), 10, 5, "12345678901234567890", S("abcdefghij12345678901234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "", S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345", S("abcdefghij12345t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "1234567890", S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", S("abcdefghij12345678901234567890t"));
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, "", S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "1234567890", S("abcdefghij1234567890"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345678901234567890", S("abcdefghij12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "", S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345", S("abcdefghijklmnopqrs12345t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "1234567890", S("abcdefghijklmnopqrs1234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345678901234567890", S("abcdefghijklmnopqrs12345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 1, "", S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 1, "12345", S("abcdefghijklmnopqrs12345"));
     test(S("abcdefghijklmnopqrst"), 19, 1, "1234567890", S("abcdefghijklmnopqrs1234567890"));
     test(S("abcdefghijklmnopqrst"), 19, 1, "12345678901234567890", S("abcdefghijklmnopqrs12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "", S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345", S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #endif
 
-    { // test replacing into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
     assert(s_short == "123/123/");
     s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
     assert(s_short == "123/123/123/123/");
     s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
 
+  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.modifiers/string_replace/iter_iter_pointer_size.pass.cpp

 #include <string>
 #include <algorithm>
 #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 pos1, typename S::size_type n1, const typename S::value_type* str,
      typename S::size_type n2, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str, n2);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = n2;
     assert(s.size() == old_size - xlen + rlen);
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, "", 0, S(""));
     test(S(""), 0, 0, "12345", 0, S(""));
     test(S(""), 0, 0, "12345", 1, S("1"));
     test(S(""), 0, 0, "12345", 2, S("12"));
     test(S(""), 0, 0, "12345", 4, S("1234"));
     test(S(""), 0, 0, "12345", 5, S("12345"));
     test(S(""), 0, 0, "1234567890", 0, S(""));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S("abcde"), 0, 5, "12345678901234567890", 1, S("1"));
     test(S("abcde"), 0, 5, "12345678901234567890", 10, S("1234567890"));
     test(S("abcde"), 0, 5, "12345678901234567890", 19, S("1234567890123456789"));
     test(S("abcde"), 0, 5, "12345678901234567890", 20, S("12345678901234567890"));
     test(S("abcde"), 1, 0, "", 0, S("abcde"));
     test(S("abcde"), 1, 0, "12345", 0, S("abcde"));
     test(S("abcde"), 1, 0, "12345", 1, S("a1bcde"));
     test(S("abcde"), 1, 0, "12345", 2, S("a12bcde"));
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S("abcde"), 1, 0, "12345", 4, S("a1234bcde"));
     test(S("abcde"), 1, 0, "12345", 5, S("a12345bcde"));
     test(S("abcde"), 1, 0, "1234567890", 0, S("abcde"));
     test(S("abcde"), 1, 0, "1234567890", 1, S("a1bcde"));
     test(S("abcde"), 1, 0, "1234567890", 5, S("a12345bcde"));
     test(S("abcde"), 1, 0, "1234567890", 9, S("a123456789bcde"));
     test(S("abcde"), 1, 0, "1234567890", 10, S("a1234567890bcde"));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S("abcde"), 2, 1, "", 0, S("abde"));
     test(S("abcde"), 2, 1, "12345", 0, S("abde"));
     test(S("abcde"), 2, 1, "12345", 1, S("ab1de"));
     test(S("abcde"), 2, 1, "12345", 2, S("ab12de"));
     test(S("abcde"), 2, 1, "12345", 4, S("ab1234de"));
     test(S("abcde"), 2, 1, "12345", 5, S("ab12345de"));
     test(S("abcde"), 2, 1, "1234567890", 0, S("abde"));
     test(S("abcde"), 2, 1, "1234567890", 1, S("ab1de"));
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S("abcde"), 2, 1, "1234567890", 5, S("ab12345de"));
     test(S("abcde"), 2, 1, "1234567890", 9, S("ab123456789de"));
     test(S("abcde"), 2, 1, "1234567890", 10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, "12345678901234567890", 0, S("abde"));
     test(S("abcde"), 2, 1, "12345678901234567890", 1, S("ab1de"));
     test(S("abcde"), 2, 1, "12345678901234567890", 10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, "12345678901234567890", 19, S("ab1234567890123456789de"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcdefghij"), 0, 0, "12345", 4, S("1234abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345", 5, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 5, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 9, S("123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 19, S("1234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 20, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, 1, "", 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, "12345", 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, "12345", 1, S("1bcdefghij"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcdefghij"), 1, 1, "1234567890", 5, S("a12345cdefghij"));
     test(S("abcdefghij"), 1, 1, "1234567890", 9, S("a123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, "1234567890", 10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 19, S("a1234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 20, S("a12345678901234567890cdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcdefghij"), 1, 4, "", 0, S("afghij"));
     test(S("abcdefghij"), 1, 4, "12345", 0, S("afghij"));
     test(S("abcdefghij"), 1, 4, "12345", 1, S("a1fghij"));
     test(S("abcdefghij"), 1, 4, "12345", 2, S("a12fghij"));
     test(S("abcdefghij"), 1, 4, "12345", 4, S("a1234fghij"));
     test(S("abcdefghij"), 1, 4, "12345", 5, S("a12345fghij"));
     test(S("abcdefghij"), 1, 4, "1234567890", 0, S("afghij"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcdefghij"), 5, 2, "12345678901234567890", 1, S("abcde1hij"));
     test(S("abcdefghij"), 5, 2, "12345678901234567890", 10, S("abcde1234567890hij"));
     test(S("abcdefghij"), 5, 2, "12345678901234567890", 19, S("abcde1234567890123456789hij"));
     test(S("abcdefghij"), 5, 2, "12345678901234567890", 20, S("abcde12345678901234567890hij"));
     test(S("abcdefghij"), 5, 4, "", 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, "12345", 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, "12345", 1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, "12345", 2, S("abcde12j"));
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcdefghij"), 5, 4, "12345", 4, S("abcde1234j"));
     test(S("abcdefghij"), 5, 4, "12345", 5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, "1234567890", 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, "1234567890", 1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, "1234567890", 5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, "1234567890", 9, S("abcde123456789j"));
     test(S("abcdefghij"), 5, 4, "1234567890", 10, S("abcde1234567890j"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcdefghijklmnopqrst"), 0, 1, "", 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 2, S("12bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 4, S("1234bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 1, S("1bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 9, S("123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 19, S("1234567890123456789bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345", 4, S("a1234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345", 5, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 5, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 9, S("a123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 10, S("a1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 0, S("aklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 10, S("a1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 19, S("a1234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 20, S("a12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 18, "", 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, "12345", 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, "12345", 1, S("a1t"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcdefghijklmnopqrst"), 10, 9, "1234567890", 5, S("abcdefghij12345t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "1234567890", 9, S("abcdefghij123456789t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "1234567890", 10, S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 0, S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 1, S("abcdefghij1t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 10, S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 19, S("abcdefghij1234567890123456789t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 20, S("abcdefghij12345678901234567890t"));
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, "", 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 1, S("abcdefghij1"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 2, S("abcdefghij12"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 4, S("abcdefghij1234"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 5, S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "1234567890", 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", 5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", 9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 19, S("abcdefghijklmnopqrst1234567890123456789"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 20, S("abcdefghijklmnopqrst12345678901234567890"));
-}
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    }
-#endif
+    return true;
 
-    { // test replacing into self
-    typedef std::string S;
-    S s_short = "123/";
-    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+template <class S>
+bool test9() {
 
-    s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
-    assert(s_short == "123/123/");
-    s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
-    assert(s_short == "123/123/123/123/");
-    s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
-    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-    s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
-    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-    }
+
+  return true;
 
+template <class S>
+void test() {
+  test0<S>();
+  test1<S>();
+  test2<S>();
+  test3<S>();
+  test4<S>();
+  test5<S>();
+  test6<S>();
+  test7<S>();
+  test8<S>();
+  test9<S>();
+
+#if TEST_STD_VER > 17
+  // static_assert(test0<S>());
+  // static_assert(test1<S>());
+  // static_assert(test2<S>());
+  // static_assert(test3<S>());
+  // static_assert(test4<S>());
+  // static_assert(test5<S>());
+  // static_assert(test6<S>());
+  // static_assert(test7<S>());
+  // static_assert(test8<S>());
+  // static_assert(test9<S>());
+#endif
+}
+
+int main(int, char**)
+{
+  test<std::string>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp

 #include <string>
 #include <algorithm>
 #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 pos1, typename S::size_type n1, typename S::size_type n2,
      typename S::value_type c, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, n2, c);
void test2()
     test(S("abcdefghijklmnopqrst"), 19, 1, 10, '3', S("abcdefghijklmnopqrs3333333333"));
     test(S("abcdefghijklmnopqrst"), 19, 1, 20, '3', S("abcdefghijklmnopqrs33333333333333333333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 0, '3', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 5, '3', S("abcdefghijklmnopqrst33333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 10, '3', S("abcdefghijklmnopqrst3333333333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 20, '3', S("abcdefghijklmnopqrst33333333333333333333"));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp

 #include <string>
 #include <algorithm>
 #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 pos1, typename S::size_type n1, S str, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = str.size();
     assert(s.size() == old_size - xlen + rlen);
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, S(""), S(""));
     test(S(""), 0, 0, S("12345"), S("12345"));
     test(S(""), 0, 0, S("1234567890"), S("1234567890"));
     test(S(""), 0, 0, S("12345678901234567890"), S("12345678901234567890"));
     test(S("abcde"), 0, 0, S(""), S("abcde"));
     test(S("abcde"), 0, 0, S("12345"), S("12345abcde"));
     test(S("abcde"), 0, 0, S("1234567890"), S("1234567890abcde"));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdefghij"), 1, 0, S("12345678901234567890"), S("a12345678901234567890bcdefghij"));
     test(S("abcdefghij"), 1, 1, S(""), S("acdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345"), S("a12345cdefghij"));
     test(S("abcdefghij"), 1, 1, S("1234567890"), S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), S("a12345678901234567890cdefghij"));
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcdefghij"), 1, 4, S(""), S("afghij"));
     test(S("abcdefghij"), 1, 4, S("12345"), S("a12345fghij"));
     test(S("abcdefghij"), 1, 4, S("1234567890"), S("a1234567890fghij"));
     test(S("abcdefghij"), 1, 4, S("12345678901234567890"), S("a12345678901234567890fghij"));
     test(S("abcdefghij"), 1, 8, S(""), S("aj"));
     test(S("abcdefghij"), 1, 8, S("12345"), S("a12345j"));
     test(S("abcdefghij"), 1, 8, S("1234567890"), S("a1234567890j"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), S("abcdefghij12345678901234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 9, S(""), S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 9, S("12345"), S("abcdefghij12345t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, S("1234567890"), S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, S("12345678901234567890"), S("abcdefghij12345678901234567890t"));
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, S(""), S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("1234567890"), S("abcdefghij1234567890"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345678901234567890"), S("abcdefghij12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345"), S("abcdefghijklmnopqrs12345t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 1, S(""), S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 1, S("12345"), S("abcdefghijklmnopqrs12345"));
     test(S("abcdefghijklmnopqrst"), 19, 1, S("1234567890"), S("abcdefghijklmnopqrs1234567890"));
     test(S("abcdefghijklmnopqrst"), 19, 1, S("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("12345"), S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
+  { // LWG 2946
     std::string s = "  ";
     s.replace(s.cbegin(), s.cend(), {"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.modifiers/string_replace/iter_iter_string_view.pass.cpp

 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, sv);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = sv.size();
     assert(s.size() == old_size - xlen + rlen);
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, SV(""), S(""));
     test(S(""), 0, 0, SV("12345"), S("12345"));
     test(S(""), 0, 0, SV("1234567890"), S("1234567890"));
     test(S(""), 0, 0, SV("12345678901234567890"), S("12345678901234567890"));
     test(S("abcde"), 0, 0, SV(""), S("abcde"));
     test(S("abcde"), 0, 0, SV("12345"), S("12345abcde"));
     test(S("abcde"), 0, 0, SV("1234567890"), S("1234567890abcde"));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcdefghij"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
     test(S("abcdefghij"), 1, 1, SV(""), S("acdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345"), S("a12345cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("1234567890"), S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghij"));
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcdefghij"), 1, 4, SV(""), S("afghij"));
     test(S("abcdefghij"), 1, 4, SV("12345"), S("a12345fghij"));
     test(S("abcdefghij"), 1, 4, SV("1234567890"), S("a1234567890fghij"));
     test(S("abcdefghij"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890fghij"));
     test(S("abcdefghij"), 1, 8, SV(""), S("aj"));
     test(S("abcdefghij"), 1, 8, SV("12345"), S("a12345j"));
     test(S("abcdefghij"), 1, 8, SV("1234567890"), S("a1234567890j"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), S("abcdefghij12345678901234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 9, SV(""), S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345"), S("abcdefghij12345t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, SV("1234567890"), S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345678901234567890"), S("abcdefghij12345678901234567890t"));
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, SV(""), S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("1234567890"), S("abcdefghij1234567890"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345"), S("abcdefghijklmnopqrs12345t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345"), S("abcdefghijklmnopqrs12345"));
     test(S("abcdefghijklmnopqrst"), 19, 1, SV("1234567890"), S("abcdefghijklmnopqrs1234567890"));
     test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345"), S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     typedef typename S::size_type SizeT;
     static_assert((!std::is_same<S, SV>::value), "");
 
     // String and string_view may not always share the same size type,
else
             assert(pos1 > old_size || pos2 > sv.size());
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, typename S::size_type pos1, typename S::size_type n1,
           SV sv, typename S::size_type pos2,
           S expected)
 {
     typedef typename S::size_type SizeT;
     static_assert((!std::is_same<S, SV>::value), "");
     const SizeT old_size = s.size();
     S s0 = s;
else
             assert(s == s0);
         }
     }
 #endif
 }
 
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, SV(""), 0, 0, S(""));
     test(S(""), 0, 0, SV(""), 0, 1, S(""));
     test(S(""), 0, 0, SV(""), 1, 0, S("can't happen"));
     test(S(""), 0, 0, SV("12345"), 0, 0, S(""));
     test(S(""), 0, 0, SV("12345"), 0, 1, S("1"));
     test(S(""), 0, 0, SV("12345"), 0, 2, S("12"));
     test(S(""), 0, 0, SV("12345"), 0, 4, S("1234"));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, 1, SV("12345"), 2, 3, S("345"));
     test(S(""), 0, 1, SV("12345"), 2, 4, S("345"));
     test(S(""), 0, 1, SV("12345"), 4, 0, S(""));
     test(S(""), 0, 1, SV("12345"), 4, 1, S("5"));
     test(S(""), 0, 1, SV("12345"), 4, 2, S("5"));
     test(S(""), 0, 1, SV("12345"), 5, 0, S(""));
     test(S(""), 0, 1, SV("12345"), 5, 1, S(""));
     test(S(""), 0, 1, SV("12345"), 6, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, 1, SV("1234567890"), 0, 0, S(""));
     test(S(""), 0, 1, SV("1234567890"), 0, 1, S("1"));
     test(S(""), 0, 1, SV("1234567890"), 0, 5, S("12345"));
     test(S(""), 0, 1, SV("1234567890"), 0, 9, S("123456789"));
     test(S(""), 0, 1, SV("1234567890"), 0, 10, S("1234567890"));
     test(S(""), 0, 1, SV("1234567890"), 0, 11, S("1234567890"));
     test(S(""), 0, 1, SV("1234567890"), 1, 0, S(""));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, 0, SV("1234567890"), 9, 0, S("can't happen"));
     test(S(""), 1, 0, SV("1234567890"), 9, 1, S("can't happen"));
     test(S(""), 1, 0, SV("1234567890"), 9, 2, S("can't happen"));
     test(S(""), 1, 0, SV("1234567890"), 10, 0, S("can't happen"));
     test(S(""), 1, 0, SV("1234567890"), 10, 1, S("can't happen"));
     test(S(""), 1, 0, SV("1234567890"), 11, 0, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 0, 0, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 0, 1, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, 0, SV("12345678901234567890"), 0, 10, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 0, 19, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 0, 20, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 0, 21, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 1, 0, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 1, 1, S("can't happen"));
     test(S(""), 1, 0, SV("12345678901234567890"), 1, 9, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcde"), 0, 0, SV("12345678901234567890"), 19, 2, S("0abcde"));
     test(S("abcde"), 0, 0, SV("12345678901234567890"), 20, 0, S("abcde"));
     test(S("abcde"), 0, 0, SV("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 0, 0, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 0, 1, SV(""), 0, 0, S("bcde"));
     test(S("abcde"), 0, 1, SV(""), 0, 1, S("bcde"));
     test(S("abcde"), 0, 1, SV(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, 1, SV("12345"), 0, 0, S("bcde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, 1, SV("12345"), 0, 1, S("1bcde"));
     test(S("abcde"), 0, 1, SV("12345"), 0, 2, S("12bcde"));
     test(S("abcde"), 0, 1, SV("12345"), 0, 4, S("1234bcde"));
     test(S("abcde"), 0, 1, SV("12345"), 0, 5, S("12345bcde"));
     test(S("abcde"), 0, 1, SV("12345"), 0, 6, S("12345bcde"));
     test(S("abcde"), 0, 1, SV("12345"), 1, 0, S("bcde"));
     test(S("abcde"), 0, 1, SV("12345"), 1, 1, S("2bcde"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, 2, SV("12345"), 4, 2, S("5cde"));
     test(S("abcde"), 0, 2, SV("12345"), 5, 0, S("cde"));
     test(S("abcde"), 0, 2, SV("12345"), 5, 1, S("cde"));
     test(S("abcde"), 0, 2, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 0, 2, SV("1234567890"), 0, 0, S("cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 0, 1, S("1cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 0, 5, S("12345cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 0, 9, S("123456789cde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, 2, SV("1234567890"), 0, 10, S("1234567890cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 0, 11, S("1234567890cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 1, 0, S("cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 1, 1, S("2cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 1, 4, S("2345cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 1, 8, S("23456789cde"));
     test(S("abcde"), 0, 2, SV("1234567890"), 1, 9, S("234567890cde"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 0, 4, SV("1234567890"), 10, 1, S("e"));
     test(S("abcde"), 0, 4, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 0, 0, S("e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 0, 1, S("1e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 0, 10, S("1234567890e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 0, 19, S("1234567890123456789e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 0, 20, S("12345678901234567890e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 0, 21, S("12345678901234567890e"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 1, 0, S("e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 1, 1, S("2e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 1, 9, S("234567890e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 1, 18, S("234567890123456789e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 1, 19, S("2345678901234567890e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 1, 20, S("2345678901234567890e"));
     test(S("abcde"), 0, 4, SV("12345678901234567890"), 10, 0, S("e"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 0, 6, SV(""), 0, 0, S(""));
     test(S("abcde"), 0, 6, SV(""), 0, 1, S(""));
     test(S("abcde"), 0, 6, SV(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, 6, SV("12345"), 0, 0, S(""));
     test(S("abcde"), 0, 6, SV("12345"), 0, 1, S("1"));
     test(S("abcde"), 0, 6, SV("12345"), 0, 2, S("12"));
     test(S("abcde"), 0, 6, SV("12345"), 0, 4, S("1234"));
     test(S("abcde"), 0, 6, SV("12345"), 0, 5, S("12345"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 0, 6, SV("12345"), 0, 6, S("12345"));
     test(S("abcde"), 0, 6, SV("12345"), 1, 0, S(""));
     test(S("abcde"), 0, 6, SV("12345"), 1, 1, S("2"));
     test(S("abcde"), 0, 6, SV("12345"), 1, 2, S("23"));
     test(S("abcde"), 0, 6, SV("12345"), 1, 3, S("234"));
     test(S("abcde"), 0, 6, SV("12345"), 1, 4, S("2345"));
     test(S("abcde"), 0, 6, SV("12345"), 1, 5, S("2345"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 1, 0, SV("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 0, 1, S("a1bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 0, 5, S("a12345bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 0, 9, S("a123456789bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 0, 10, S("a1234567890bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 0, 11, S("a1234567890bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 1, 1, S("a2bcde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 1, 0, SV("1234567890"), 1, 4, S("a2345bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 1, 8, S("a23456789bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 1, 9, S("a234567890bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 1, 10, S("a234567890bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 5, 0, S("abcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 5, 1, S("a6bcde"));
     test(S("abcde"), 1, 0, SV("1234567890"), 5, 2, S("a67bcde"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 0, 10, S("a1234567890cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 0, 19, S("a1234567890123456789cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 0, 20, S("a12345678901234567890cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 0, 21, S("a12345678901234567890cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 1, 0, S("acde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 1, 1, S("a2cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 1, 9, S("a234567890cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 1, 18, S("a234567890123456789cde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 1, 19, S("a2345678901234567890cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 1, 20, S("a2345678901234567890cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 10, 0, S("acde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 10, 1, S("a1cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 10, 5, S("a12345cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 10, 9, S("a123456789cde"));
     test(S("abcde"), 1, 1, SV("12345678901234567890"), 10, 10, S("a1234567890cde"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 1, 3, SV("12345"), 0, 1, S("a1e"));
     test(S("abcde"), 1, 3, SV("12345"), 0, 2, S("a12e"));
     test(S("abcde"), 1, 3, SV("12345"), 0, 4, S("a1234e"));
     test(S("abcde"), 1, 3, SV("12345"), 0, 5, S("a12345e"));
     test(S("abcde"), 1, 3, SV("12345"), 0, 6, S("a12345e"));
     test(S("abcde"), 1, 3, SV("12345"), 1, 0, S("ae"));
     test(S("abcde"), 1, 3, SV("12345"), 1, 1, S("a2e"));
     test(S("abcde"), 1, 3, SV("12345"), 1, 2, S("a23e"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 1, 3, SV("12345"), 1, 3, S("a234e"));
     test(S("abcde"), 1, 3, SV("12345"), 1, 4, S("a2345e"));
     test(S("abcde"), 1, 3, SV("12345"), 1, 5, S("a2345e"));
     test(S("abcde"), 1, 3, SV("12345"), 2, 0, S("ae"));
     test(S("abcde"), 1, 3, SV("12345"), 2, 1, S("a3e"));
     test(S("abcde"), 1, 3, SV("12345"), 2, 2, S("a34e"));
     test(S("abcde"), 1, 3, SV("12345"), 2, 3, S("a345e"));
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 1, 4, SV("1234567890"), 0, 10, S("a1234567890"));
     test(S("abcde"), 1, 4, SV("1234567890"), 0, 11, S("a1234567890"));
     test(S("abcde"), 1, 4, SV("1234567890"), 1, 0, S("a"));
     test(S("abcde"), 1, 4, SV("1234567890"), 1, 1, S("a2"));
     test(S("abcde"), 1, 4, SV("1234567890"), 1, 4, S("a2345"));
     test(S("abcde"), 1, 4, SV("1234567890"), 1, 8, S("a23456789"));
     test(S("abcde"), 1, 4, SV("1234567890"), 1, 9, S("a234567890"));
     test(S("abcde"), 1, 4, SV("1234567890"), 1, 10, S("a234567890"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 1, 4, SV("1234567890"), 5, 0, S("a"));
     test(S("abcde"), 1, 4, SV("1234567890"), 5, 1, S("a6"));
     test(S("abcde"), 1, 4, SV("1234567890"), 5, 2, S("a67"));
     test(S("abcde"), 1, 4, SV("1234567890"), 5, 4, S("a6789"));
     test(S("abcde"), 1, 4, SV("1234567890"), 5, 5, S("a67890"));
     test(S("abcde"), 1, 4, SV("1234567890"), 5, 6, S("a67890"));
     test(S("abcde"), 1, 4, SV("1234567890"), 9, 0, S("a"));
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 1, 0, S("a"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 1, 1, S("a2"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 1, 9, S("a234567890"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 1, 18, S("a234567890123456789"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 1, 19, S("a2345678901234567890"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 1, 20, S("a2345678901234567890"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 10, 0, S("a"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 10, 1, S("a1"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 10, 5, S("a12345"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 10, 9, S("a123456789"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 10, 10, S("a1234567890"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 10, 11, S("a1234567890"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 19, 0, S("a"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 19, 1, S("a0"));
     test(S("abcde"), 1, 5, SV("12345678901234567890"), 19, 2, S("a0"));
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcde"), 2, 1, SV("12345"), 0, 6, S("ab12345de"));
     test(S("abcde"), 2, 1, SV("12345"), 1, 0, S("abde"));
     test(S("abcde"), 2, 1, SV("12345"), 1, 1, S("ab2de"));
     test(S("abcde"), 2, 1, SV("12345"), 1, 2, S("ab23de"));
     test(S("abcde"), 2, 1, SV("12345"), 1, 3, S("ab234de"));
     test(S("abcde"), 2, 1, SV("12345"), 1, 4, S("ab2345de"));
     test(S("abcde"), 2, 1, SV("12345"), 1, 5, S("ab2345de"));
     test(S("abcde"), 2, 1, SV("12345"), 2, 0, S("abde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcde"), 2, 1, SV("12345"), 2, 1, S("ab3de"));
     test(S("abcde"), 2, 1, SV("12345"), 2, 2, S("ab34de"));
     test(S("abcde"), 2, 1, SV("12345"), 2, 3, S("ab345de"));
     test(S("abcde"), 2, 1, SV("12345"), 2, 4, S("ab345de"));
     test(S("abcde"), 2, 1, SV("12345"), 4, 0, S("abde"));
     test(S("abcde"), 2, 1, SV("12345"), 4, 1, S("ab5de"));
     test(S("abcde"), 2, 1, SV("12345"), 4, 2, S("ab5de"));
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcde"), 2, 2, SV("1234567890"), 1, 4, S("ab2345e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 1, 8, S("ab23456789e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 1, 9, S("ab234567890e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 1, 10, S("ab234567890e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 5, 0, S("abe"));
     test(S("abcde"), 2, 2, SV("1234567890"), 5, 1, S("ab6e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 5, 2, S("ab67e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 5, 4, S("ab6789e"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcde"), 2, 2, SV("1234567890"), 5, 5, S("ab67890e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 5, 6, S("ab67890e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 9, 0, S("abe"));
     test(S("abcde"), 2, 2, SV("1234567890"), 9, 1, S("ab0e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 9, 2, S("ab0e"));
     test(S("abcde"), 2, 2, SV("1234567890"), 10, 0, S("abe"));
     test(S("abcde"), 2, 2, SV("1234567890"), 10, 1, S("abe"));
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 1, 19, S("ab2345678901234567890"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 1, 20, S("ab2345678901234567890"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 10, 0, S("ab"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 10, 1, S("ab1"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 10, 5, S("ab12345"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 10, 9, S("ab123456789"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 10, 10, S("ab1234567890"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 10, 11, S("ab1234567890"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 19, 0, S("ab"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 19, 1, S("ab0"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 19, 2, S("ab0"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 20, 0, S("ab"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 20, 1, S("ab"));
     test(S("abcde"), 2, 3, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 2, 4, SV(""), 0, 0, S("ab"));
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcde"), 4, 0, SV("12345"), 1, 3, S("abcd234e"));
     test(S("abcde"), 4, 0, SV("12345"), 1, 4, S("abcd2345e"));
     test(S("abcde"), 4, 0, SV("12345"), 1, 5, S("abcd2345e"));
     test(S("abcde"), 4, 0, SV("12345"), 2, 0, S("abcde"));
     test(S("abcde"), 4, 0, SV("12345"), 2, 1, S("abcd3e"));
     test(S("abcde"), 4, 0, SV("12345"), 2, 2, S("abcd34e"));
     test(S("abcde"), 4, 0, SV("12345"), 2, 3, S("abcd345e"));
     test(S("abcde"), 4, 0, SV("12345"), 2, 4, S("abcd345e"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcde"), 4, 0, SV("12345"), 4, 0, S("abcde"));
     test(S("abcde"), 4, 0, SV("12345"), 4, 1, S("abcd5e"));
     test(S("abcde"), 4, 0, SV("12345"), 4, 2, S("abcd5e"));
     test(S("abcde"), 4, 0, SV("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 4, 0, SV("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 4, 0, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 4, 0, SV("1234567890"), 0, 0, S("abcde"));
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcde"), 4, 1, SV("1234567890"), 5, 0, S("abcd"));
     test(S("abcde"), 4, 1, SV("1234567890"), 5, 1, S("abcd6"));
     test(S("abcde"), 4, 1, SV("1234567890"), 5, 2, S("abcd67"));
     test(S("abcde"), 4, 1, SV("1234567890"), 5, 4, S("abcd6789"));
     test(S("abcde"), 4, 1, SV("1234567890"), 5, 5, S("abcd67890"));
     test(S("abcde"), 4, 1, SV("1234567890"), 5, 6, S("abcd67890"));
     test(S("abcde"), 4, 1, SV("1234567890"), 9, 0, S("abcd"));
     test(S("abcde"), 4, 1, SV("1234567890"), 9, 1, S("abcd0"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcde"), 4, 1, SV("1234567890"), 9, 2, S("abcd0"));
     test(S("abcde"), 4, 1, SV("1234567890"), 10, 0, S("abcd"));
     test(S("abcde"), 4, 1, SV("1234567890"), 10, 1, S("abcd"));
     test(S("abcde"), 4, 1, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 4, 1, SV("12345678901234567890"), 0, 0, S("abcd"));
     test(S("abcde"), 4, 1, SV("12345678901234567890"), 0, 1, S("abcd1"));
     test(S("abcde"), 4, 1, SV("12345678901234567890"), 0, 10, S("abcd1234567890"));
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 10, 5, S("abcd12345"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 10, 9, S("abcd123456789"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 10, 10, S("abcd1234567890"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 10, 11, S("abcd1234567890"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 19, 0, S("abcd"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 19, 1, S("abcd0"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 19, 2, S("abcd0"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 20, 0, S("abcd"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 20, 1, S("abcd"));
     test(S("abcde"), 4, 2, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 5, 0, SV(""), 0, 0, S("abcde"));
     test(S("abcde"), 5, 0, SV(""), 0, 1, S("abcde"));
     test(S("abcde"), 5, 0, SV(""), 1, 0, S("can't happen"));
     test(S("abcde"), 5, 0, SV("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 5, 0, SV("12345"), 0, 1, S("abcde1"));
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcde"), 5, 1, SV("12345"), 2, 1, S("abcde3"));
     test(S("abcde"), 5, 1, SV("12345"), 2, 2, S("abcde34"));
     test(S("abcde"), 5, 1, SV("12345"), 2, 3, S("abcde345"));
     test(S("abcde"), 5, 1, SV("12345"), 2, 4, S("abcde345"));
     test(S("abcde"), 5, 1, SV("12345"), 4, 0, S("abcde"));
     test(S("abcde"), 5, 1, SV("12345"), 4, 1, S("abcde5"));
     test(S("abcde"), 5, 1, SV("12345"), 4, 2, S("abcde5"));
     test(S("abcde"), 5, 1, SV("12345"), 5, 0, S("abcde"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcde"), 5, 1, SV("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 5, 1, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 5, 1, SV("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 5, 1, SV("1234567890"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, 1, SV("1234567890"), 0, 5, S("abcde12345"));
     test(S("abcde"), 5, 1, SV("1234567890"), 0, 9, S("abcde123456789"));
     test(S("abcde"), 5, 1, SV("1234567890"), 0, 10, S("abcde1234567890"));
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcde"), 6, 0, SV("1234567890"), 5, 5, S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), 5, 6, S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), 9, 0, S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), 9, 1, S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), 9, 2, S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), 10, 0, S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), 10, 1, S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), 11, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcde"), 6, 0, SV("12345678901234567890"), 0, 0, S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345678901234567890"), 0, 1, S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345678901234567890"), 0, 10, S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345678901234567890"), 0, 19, S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345678901234567890"), 0, 20, S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345678901234567890"), 0, 21, S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345678901234567890"), 1, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), 19, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), 19, 1, S("0abcdefghij"));
     test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), 19, 2, S("0abcdefghij"));
     test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), 20, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), 20, 1, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 1, SV(""), 0, 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, SV(""), 0, 1, S("bcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test20()
+TEST_CONSTEXPR_CXX20 bool test20()
 {
     test(S("abcdefghij"), 0, 1, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 1, SV("12345"), 0, 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, SV("12345"), 0, 1, S("1bcdefghij"));
     test(S("abcdefghij"), 0, 1, SV("12345"), 0, 2, S("12bcdefghij"));
     test(S("abcdefghij"), 0, 1, SV("12345"), 0, 4, S("1234bcdefghij"));
     test(S("abcdefghij"), 0, 1, SV("12345"), 0, 5, S("12345bcdefghij"));
     test(S("abcdefghij"), 0, 1, SV("12345"), 0, 6, S("12345bcdefghij"));
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghij"), 0, 5, SV("12345"), 4, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, SV("12345"), 4, 1, S("5fghij"));
     test(S("abcdefghij"), 0, 5, SV("12345"), 4, 2, S("5fghij"));
     test(S("abcdefghij"), 0, 5, SV("12345"), 5, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, SV("12345"), 5, 1, S("fghij"));
     test(S("abcdefghij"), 0, 5, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 0, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 0, 1, S("1fghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 0, 5, S("12345fghij"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 0, 9, S("123456789fghij"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 0, 10, S("1234567890fghij"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 0, 11, S("1234567890fghij"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 1, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 1, 1, S("2fghij"));
     test(S("abcdefghij"), 0, 5, SV("1234567890"), 1, 4, S("2345fghij"));
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghij"), 0, 9, SV("1234567890"), 9, 2, S("0j"));
     test(S("abcdefghij"), 0, 9, SV("1234567890"), 10, 0, S("j"));
     test(S("abcdefghij"), 0, 9, SV("1234567890"), 10, 1, S("j"));
     test(S("abcdefghij"), 0, 9, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 0, 0, S("j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 0, 1, S("1j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 0, 10, S("1234567890j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 0, 19, S("1234567890123456789j"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 0, 20, S("12345678901234567890j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 0, 21, S("12345678901234567890j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 1, 0, S("j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 1, 1, S("2j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 1, 9, S("234567890j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 1, 18, S("234567890123456789j"));
     test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), 1, 19, S("2345678901234567890j"));
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghij"), 0, 10, SV("12345678901234567890"), 20, 1, S(""));
     test(S("abcdefghij"), 0, 10, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 11, SV(""), 0, 0, S(""));
     test(S("abcdefghij"), 0, 11, SV(""), 0, 1, S(""));
     test(S("abcdefghij"), 0, 11, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 11, SV("12345"), 0, 0, S(""));
     test(S("abcdefghij"), 0, 11, SV("12345"), 0, 1, S("1"));
     test(S("abcdefghij"), 0, 11, SV("12345"), 0, 2, S("12"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghij"), 0, 11, SV("12345"), 0, 4, S("1234"));
     test(S("abcdefghij"), 0, 11, SV("12345"), 0, 5, S("12345"));
     test(S("abcdefghij"), 0, 11, SV("12345"), 0, 6, S("12345"));
     test(S("abcdefghij"), 0, 11, SV("12345"), 1, 0, S(""));
     test(S("abcdefghij"), 0, 11, SV("12345"), 1, 1, S("2"));
     test(S("abcdefghij"), 0, 11, SV("12345"), 1, 2, S("23"));
     test(S("abcdefghij"), 0, 11, SV("12345"), 1, 3, S("234"));
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghij"), 1, 0, SV("12345"), 5, 1, S("abcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 0, 1, S("a1bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 0, 5, S("a12345bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 0, 9, S("a123456789bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 0, 10, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 0, 11, S("a1234567890bcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 1, 1, S("a2bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 1, 4, S("a2345bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 1, 8, S("a23456789bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 1, 9, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 1, 10, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, 0, SV("1234567890"), 5, 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 0, 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 0, 1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 0, 10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 0, 19, S("a1234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 0, 20, S("a12345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 0, 21, S("a12345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 1, 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 1, 1, S("a2cdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 1, 9, S("a234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 1, 18, S("a234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 1, 19, S("a2345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 1, 20, S("a2345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 10, 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 10, 1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), 10, 5, S("a12345cdefghij"));
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghij"), 1, 8, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 0, 0, S("aj"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 0, 1, S("a1j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 0, 2, S("a12j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 0, 4, S("a1234j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 0, 5, S("a12345j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 0, 6, S("a12345j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 1, 0, S("aj"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghij"), 1, 8, SV("12345"), 1, 1, S("a2j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 1, 2, S("a23j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 1, 3, S("a234j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 1, 4, S("a2345j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 1, 5, S("a2345j"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 2, 0, S("aj"));
     test(S("abcdefghij"), 1, 8, SV("12345"), 2, 1, S("a3j"));
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 0, 5, S("a12345"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 0, 9, S("a123456789"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 0, 10, S("a1234567890"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 0, 11, S("a1234567890"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 1, 0, S("a"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 1, 1, S("a2"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 1, 4, S("a2345"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 1, 8, S("a23456789"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 1, 9, S("a234567890"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 1, 10, S("a234567890"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 5, 0, S("a"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 5, 1, S("a6"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 5, 2, S("a67"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 5, 4, S("a6789"));
     test(S("abcdefghij"), 1, 9, SV("1234567890"), 5, 5, S("a67890"));
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 0, 20, S("a12345678901234567890"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 0, 21, S("a12345678901234567890"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 1, 0, S("a"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 1, 1, S("a2"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 1, 9, S("a234567890"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 1, 18, S("a234567890123456789"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 1, 19, S("a2345678901234567890"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 1, 20, S("a2345678901234567890"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 10, 0, S("a"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 10, 1, S("a1"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 10, 5, S("a12345"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 10, 9, S("a123456789"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 10, 10, S("a1234567890"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 10, 11, S("a1234567890"));
     test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), 19, 0, S("a"));
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghij"), 5, 1, SV("12345"), 0, 4, S("abcde1234ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 0, 5, S("abcde12345ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 0, 6, S("abcde12345ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 1, 0, S("abcdeghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 1, 1, S("abcde2ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 1, 2, S("abcde23ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 1, 3, S("abcde234ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 1, 4, S("abcde2345ghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test29()
+TEST_CONSTEXPR_CXX20 bool test29()
 {
     test(S("abcdefghij"), 5, 1, SV("12345"), 1, 5, S("abcde2345ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 2, 0, S("abcdeghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 2, 1, S("abcde3ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 2, 2, S("abcde34ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 2, 3, S("abcde345ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 2, 4, S("abcde345ghij"));
     test(S("abcdefghij"), 5, 1, SV("12345"), 4, 0, S("abcdeghij"));
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 1, 0, S("abcdehij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 1, 1, S("abcde2hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 1, 4, S("abcde2345hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 1, 8, S("abcde23456789hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 1, 9, S("abcde234567890hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 1, 10, S("abcde234567890hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 5, 0, S("abcdehij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 5, 1, S("abcde6hij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 5, 2, S("abcde67hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 5, 4, S("abcde6789hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 5, 5, S("abcde67890hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 5, 6, S("abcde67890hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 9, 0, S("abcdehij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 9, 1, S("abcde0hij"));
     test(S("abcdefghij"), 5, 2, SV("1234567890"), 9, 2, S("abcde0hij"));
TEST_CONSTEXPR_CXX20 bool test30()
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 1, 9, S("abcde234567890j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 1, 18, S("abcde234567890123456789j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 1, 19, S("abcde2345678901234567890j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 1, 20, S("abcde2345678901234567890j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 10, 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 10, 1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 10, 5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 10, 9, S("abcde123456789j"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test31()
+TEST_CONSTEXPR_CXX20 bool test31()
 {
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 10, 10, S("abcde1234567890j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 10, 11, S("abcde1234567890j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 19, 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 19, 1, S("abcde0j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 19, 2, S("abcde0j"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 20, 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), 20, 1, S("abcdej"));
TEST_CONSTEXPR_CXX20 bool test31()
     test(S("abcdefghij"), 5, 6, SV("12345"), 1, 1, S("abcde2"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 1, 2, S("abcde23"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 1, 3, S("abcde234"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 1, 4, S("abcde2345"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 1, 5, S("abcde2345"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 2, 0, S("abcde"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 2, 1, S("abcde3"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 2, 2, S("abcde34"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test32()
+TEST_CONSTEXPR_CXX20 bool test32()
 {
     test(S("abcdefghij"), 5, 6, SV("12345"), 2, 3, S("abcde345"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 2, 4, S("abcde345"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 4, 0, S("abcde"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 4, 1, S("abcde5"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 4, 2, S("abcde5"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 5, 0, S("abcde"));
     test(S("abcdefghij"), 5, 6, SV("12345"), 5, 1, S("abcde"));
TEST_CONSTEXPR_CXX20 bool test32()
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 1, 9, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 1, 10, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 5, 1, S("abcdefghi6j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 5, 2, S("abcdefghi67j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 5, 4, S("abcdefghi6789j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 5, 5, S("abcdefghi67890j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 5, 6, S("abcdefghi67890j"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test33()
+TEST_CONSTEXPR_CXX20 bool test33()
 {
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 9, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 9, 1, S("abcdefghi0j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 9, 2, S("abcdefghi0j"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 10, 1, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghij"), 9, 0, SV("12345678901234567890"), 0, 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test33()
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 10, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 10, 1, S("abcdefghi1"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 10, 5, S("abcdefghi12345"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 10, 9, S("abcdefghi123456789"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 10, 10, S("abcdefghi1234567890"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 10, 11, S("abcdefghi1234567890"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 19, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 19, 1, S("abcdefghi0"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test34()
+TEST_CONSTEXPR_CXX20 bool test34()
 {
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 19, 2, S("abcdefghi0"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 20, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 20, 1, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghij"), 9, 2, SV(""), 0, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 2, SV(""), 0, 1, S("abcdefghi"));
     test(S("abcdefghij"), 9, 2, SV(""), 1, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test34()
     test(S("abcdefghij"), 10, 0, SV("12345"), 1, 5, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 2, 1, S("abcdefghij3"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 2, 2, S("abcdefghij34"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 2, 3, S("abcdefghij345"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 2, 4, S("abcdefghij345"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 4, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 4, 1, S("abcdefghij5"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test35()
+TEST_CONSTEXPR_CXX20 bool test35()
 {
     test(S("abcdefghij"), 10, 0, SV("12345"), 4, 2, S("abcdefghij5"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 5, 1, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghij"), 10, 0, SV("1234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, SV("1234567890"), 0, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, 0, SV("1234567890"), 0, 5, S("abcdefghij12345"));
TEST_CONSTEXPR_CXX20 bool test35()
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 5, 2, S("abcdefghij67"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 5, 4, S("abcdefghij6789"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 5, 5, S("abcdefghij67890"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 5, 6, S("abcdefghij67890"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 9, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 9, 1, S("abcdefghij0"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 9, 2, S("abcdefghij0"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 10, 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test36()
+TEST_CONSTEXPR_CXX20 bool test36()
 {
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 10, 1, S("abcdefghij"));
     test(S("abcdefghij"), 10, 1, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), 0, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), 0, 10, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), 0, 19, S("abcdefghij1234567890123456789"));
     test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), 0, 20, S("abcdefghij12345678901234567890"));
TEST_CONSTEXPR_CXX20 bool test36()
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 10, 10, S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 10, 11, S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 19, 0, S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 19, 1, S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 19, 2, S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 20, 0, S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 20, 1, S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), 21, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test37()
+TEST_CONSTEXPR_CXX20 bool test37()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), 0, 1, S("1abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), 0, 2, S("12abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), 0, 4, S("1234abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test37()
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 2, 3, S("345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 2, 4, S("345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 4, 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 4, 1, S("5bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 4, 2, S("5bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 5, 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 5, 1, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), 6, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test38()
+TEST_CONSTEXPR_CXX20 bool test38()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), 0, 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), 0, 1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), 0, 5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), 0, 9, S("123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), 0, 10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), 0, 11, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), 1, 0, S("bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test38()
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), 9, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), 9, 1, S("0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), 9, 2, S("0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), 10, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), 10, 1, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 0, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 0, 1, S("1klmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test39()
+TEST_CONSTEXPR_CXX20 bool test39()
 {
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 0, 10, S("1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 0, 19, S("1234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 0, 20, S("12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 0, 21, S("12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 1, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 1, 1, S("2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), 1, 9, S("234567890klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test39()
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), 19, 2, S("0t"));
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), 20, 0, S("t"));
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), 20, 1, S("t"));
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 0, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 0, 1, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 0, 0, S(""));
+
+    return true;
 }
 
 template <class S, class SV>
-void test40()
+TEST_CONSTEXPR_CXX20 bool test40()
 {
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 0, 1, S("1"));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 0, 2, S("12"));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 0, 4, S("1234"));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 0, 5, S("12345"));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 0, 6, S("12345"));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 1, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), 1, 1, S("2"));
TEST_CONSTEXPR_CXX20 bool test40()
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345"), 4, 2, S("5"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345"), 5, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345"), 5, 1, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 0, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 0, 1, S("1"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 0, 5, S("12345"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 0, 9, S("123456789"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test41()
+TEST_CONSTEXPR_CXX20 bool test41()
 {
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 0, 10, S("1234567890"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 0, 11, S("1234567890"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 1, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 1, 1, S("2"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 1, 4, S("2345"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 1, 8, S("23456789"));
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), 1, 9, S("234567890"));
TEST_CONSTEXPR_CXX20 bool test41()
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("1234567890"), 10, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 0, 1, S("a1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 0, 10, S("a1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 0, 19, S("a1234567890123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 0, 20, S("a12345678901234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 0, 21, S("a12345678901234567890bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test42()
+TEST_CONSTEXPR_CXX20 bool test42()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 1, 1, S("a2bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 1, 9, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 1, 18, S("a234567890123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 1, 19, S("a2345678901234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 1, 20, S("a2345678901234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test42()
     test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), 0, 0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), 0, 1, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 0, 0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 0, 1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 0, 2, S("a12klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 0, 4, S("a1234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 0, 5, S("a12345klmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test43()
+TEST_CONSTEXPR_CXX20 bool test43()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 0, 6, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 1, 0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 1, 1, S("a2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 1, 2, S("a23klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 1, 3, S("a234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 1, 4, S("a2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), 1, 5, S("a2345klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test43()
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 0, 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 0, 1, S("a1t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 0, 5, S("a12345t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 0, 9, S("a123456789t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 0, 10, S("a1234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 0, 11, S("a1234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 1, 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 1, 1, S("a2t"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test44()
+TEST_CONSTEXPR_CXX20 bool test44()
 {
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 1, 4, S("a2345t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 1, 8, S("a23456789t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 1, 9, S("a234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 1, 10, S("a234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 5, 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 5, 1, S("a6t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), 5, 2, S("a67t"));
TEST_CONSTEXPR_CXX20 bool test44()
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 0, 10, S("a1234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 0, 19, S("a1234567890123456789"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 0, 20, S("a12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 0, 21, S("a12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 1, 0, S("a"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 1, 1, S("a2"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 1, 9, S("a234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 1, 18, S("a234567890123456789"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test45()
+TEST_CONSTEXPR_CXX20 bool test45()
 {
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 1, 19, S("a2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 1, 20, S("a2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 10, 0, S("a"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 10, 1, S("a1"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 10, 5, S("a12345"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 10, 9, S("a123456789"));
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), 10, 10, S("a1234567890"));
TEST_CONSTEXPR_CXX20 bool test45()
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 0, 1, S("abcdefghij1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 0, 2, S("abcdefghij12klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 0, 4, S("abcdefghij1234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 0, 5, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 0, 6, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 1, 1, S("abcdefghij2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 1, 2, S("abcdefghij23klmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test46()
+TEST_CONSTEXPR_CXX20 bool test46()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 1, 3, S("abcdefghij234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 1, 4, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 1, 5, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 2, 1, S("abcdefghij3klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 2, 2, S("abcdefghij34klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), 2, 3, S("abcdefghij345klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test46()
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 0, 10, S("abcdefghij1234567890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 0, 11, S("abcdefghij1234567890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 1, 0, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 1, 1, S("abcdefghij2lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 1, 4, S("abcdefghij2345lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 1, 8, S("abcdefghij23456789lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 1, 9, S("abcdefghij234567890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 1, 10, S("abcdefghij234567890lmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test47()
+TEST_CONSTEXPR_CXX20 bool test47()
 {
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 5, 0, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 5, 1, S("abcdefghij6lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 5, 2, S("abcdefghij67lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 5, 4, S("abcdefghij6789lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 5, 5, S("abcdefghij67890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 5, 6, S("abcdefghij67890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), 9, 0, S("abcdefghijlmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test47()
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 1, 0, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 1, 1, S("abcdefghij2pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 1, 9, S("abcdefghij234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 10, 0, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 10, 1, S("abcdefghij1pqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test48()
+TEST_CONSTEXPR_CXX20 bool test48()
 {
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 10, 5, S("abcdefghij12345pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 10, 9, S("abcdefghij123456789pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 10, 10, S("abcdefghij1234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 10, 11, S("abcdefghij1234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 19, 0, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 19, 1, S("abcdefghij0pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), 19, 2, S("abcdefghij0pqrst"));
TEST_CONSTEXPR_CXX20 bool test48()
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 0, 6, S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 1, 2, S("abcdefghij23"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 1, 3, S("abcdefghij234"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 1, 4, S("abcdefghij2345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 1, 5, S("abcdefghij2345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 2, 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test49()
+TEST_CONSTEXPR_CXX20 bool test49()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 2, 1, S("abcdefghij3"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 2, 2, S("abcdefghij34"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 2, 3, S("abcdefghij345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 2, 4, S("abcdefghij345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 4, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 4, 1, S("abcdefghij5"));
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), 4, 2, S("abcdefghij5"));
TEST_CONSTEXPR_CXX20 bool test49()
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 1, 4, S("abcdefghij2345"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 1, 8, S("abcdefghij23456789"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 1, 9, S("abcdefghij234567890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 1, 10, S("abcdefghij234567890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 5, 1, S("abcdefghij6"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 5, 2, S("abcdefghij67"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 5, 4, S("abcdefghij6789"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test50()
+TEST_CONSTEXPR_CXX20 bool test50()
 {
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 5, 5, S("abcdefghij67890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 5, 6, S("abcdefghij67890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 9, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 9, 1, S("abcdefghij0"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 9, 2, S("abcdefghij0"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), 10, 1, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test50()
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 1, 19, S("abcdefghijklmnopqrs2345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 1, 20, S("abcdefghijklmnopqrs2345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 10, 1, S("abcdefghijklmnopqrs1t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 10, 5, S("abcdefghijklmnopqrs12345t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 10, 9, S("abcdefghijklmnopqrs123456789t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 10, 10, S("abcdefghijklmnopqrs1234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 10, 11, S("abcdefghijklmnopqrs1234567890t"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test51()
+TEST_CONSTEXPR_CXX20 bool test51()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 19, 2, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), 0, 0, S("abcdefghijklmnopqrs"));
TEST_CONSTEXPR_CXX20 bool test51()
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 1, 3, S("abcdefghijklmnopqrs234"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 1, 4, S("abcdefghijklmnopqrs2345"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 1, 5, S("abcdefghijklmnopqrs2345"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 2, 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 2, 1, S("abcdefghijklmnopqrs3"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 2, 2, S("abcdefghijklmnopqrs34"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 2, 3, S("abcdefghijklmnopqrs345"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 2, 4, S("abcdefghijklmnopqrs345"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test52()
+TEST_CONSTEXPR_CXX20 bool test52()
 {
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 4, 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 4, 1, S("abcdefghijklmnopqrs5"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 4, 2, S("abcdefghijklmnopqrs5"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 5, 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 5, 1, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("1234567890"), 0, 0, S("abcdefghijklmnopqrs"));
TEST_CONSTEXPR_CXX20 bool test52()
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 5, 1, S("abcdefghijklmnopqrst6"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 5, 2, S("abcdefghijklmnopqrst67"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 5, 4, S("abcdefghijklmnopqrst6789"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 5, 5, S("abcdefghijklmnopqrst67890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 5, 6, S("abcdefghijklmnopqrst67890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 9, 1, S("abcdefghijklmnopqrst0"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test53()
+TEST_CONSTEXPR_CXX20 bool test53()
 {
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 9, 2, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 10, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), 0, 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), 0, 10, S("abcdefghijklmnopqrst1234567890"));
TEST_CONSTEXPR_CXX20 bool test53()
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 10, 5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 10, 9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 10, 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 10, 11, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 19, 2, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test54()
+TEST_CONSTEXPR_CXX20 bool test54()
 {
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345"), 0, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345"), 0, 1, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test54()
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 10, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 10, 11, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 19, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 19, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 19, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 20, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 20, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), 21, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S, class SV>
-void test55()
+TEST_CONSTEXPR_CXX20 bool test55()
 {
     test_npos(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 10, S("abcdefghi1234567890"));
     test_npos(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 19, S("abcdefghi0"));
     test_npos(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 20, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 20, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 1, SV("12345678901234567890"), 21, S("can't happen"));
     test_npos(S("abcdefghij"), 9, 2, SV(""), 0, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 2, SV(""), 1, S("can't happen"));
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 0, S("abcdefghi12345"));
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 1, S("abcdefghi2345"));
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 2, S("abcdefghi345"));
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 4, S("abcdefghi5"));
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 5, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 6, S("can't happen"));
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
+bool test56() {
     typedef std::string S;
     typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
-    test3<S, SV>();
-    test4<S, SV>();
-    test5<S, SV>();
-    test6<S, SV>();
-    test7<S, SV>();
-    test8<S, SV>();
-    test9<S, SV>();
-    test10<S, SV>();
-    test11<S, SV>();
-    test12<S, SV>();
-    test13<S, SV>();
-    test14<S, SV>();
-    test15<S, SV>();
-    test16<S, SV>();
-    test17<S, SV>();
-    test18<S, SV>();
-    test19<S, SV>();
-    test20<S, SV>();
-    test21<S, SV>();
-    test22<S, SV>();
-    test23<S, SV>();
-    test24<S, SV>();
-    test25<S, SV>();
-    test26<S, SV>();
-    test27<S, SV>();
-    test28<S, SV>();
-    test29<S, SV>();
-    test30<S, SV>();
-    test31<S, SV>();
-    test32<S, SV>();
-    test33<S, SV>();
-    test34<S, SV>();
-    test35<S, SV>();
-    test36<S, SV>();
-    test37<S, SV>();
-    test38<S, SV>();
-    test39<S, SV>();
-    test40<S, SV>();
-    test41<S, SV>();
-    test42<S, SV>();
-    test43<S, SV>();
-    test44<S, SV>();
-    test45<S, SV>();
-    test46<S, SV>();
-    test47<S, SV>();
-    test48<S, SV>();
-    test49<S, SV>();
-    test50<S, SV>();
-    test51<S, SV>();
-    test52<S, SV>();
-    test53<S, SV>();
-    test54<S, SV>();
-    test55<S, SV>();
-    }
-#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;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
-    test3<S, SV>();
-    test4<S, SV>();
-    test5<S, SV>();
-    test6<S, SV>();
-    test7<S, SV>();
-    test8<S, SV>();
-    test9<S, SV>();
-    test10<S, SV>();
-    test11<S, SV>();
-    test12<S, SV>();
-    test13<S, SV>();
-    test14<S, SV>();
-    test15<S, SV>();
-    test16<S, SV>();
-    test17<S, SV>();
-    test18<S, SV>();
-    test19<S, SV>();
-    test20<S, SV>();
-    test21<S, SV>();
-    test22<S, SV>();
-    test23<S, SV>();
-    test24<S, SV>();
-    test25<S, SV>();
-    test26<S, SV>();
-    test27<S, SV>();
-    test28<S, SV>();
-    test29<S, SV>();
-    test30<S, SV>();
-    test31<S, SV>();
-    test32<S, SV>();
-    test33<S, SV>();
-    test34<S, SV>();
-    test35<S, SV>();
-    test36<S, SV>();
-    test37<S, SV>();
-    test38<S, SV>();
-    test39<S, SV>();
-    test40<S, SV>();
-    test41<S, SV>();
-    test42<S, SV>();
-    test43<S, SV>();
-    test44<S, SV>();
-    test45<S, SV>();
-    test46<S, SV>();
-    test47<S, SV>();
-    test48<S, SV>();
-    test49<S, SV>();
-    test50<S, SV>();
-    test51<S, SV>();
-    test52<S, SV>();
-    test53<S, SV>();
-    test54<S, SV>();
-    test55<S, SV>();
-    }
-#endif
-    {
-    typedef std::string S;
-    typedef std::string_view SV;
-    S s0 = "ABCD";
-    S s;
-    SV sv = "EFGH";
-    char arr[] = "IJKL";
-
-    s = s0;
-    s.replace(0, 4, "CDEF", 0);    // calls replace(pos1, n1, const char *, len)
-    assert(s == "");
-
-    s = s0;
-    s.replace(0, 4, "QRST", 0, std::string::npos); // calls replace(pos1, n1, string("QRST"), pos, npos)
-    assert(s == "QRST");
-
-    s = s0;
-    s.replace(0, 4, sv, 0);  // calls replace(pos1, n1, T, pos, npos)
-    assert(s == sv);
-
-    s = s0;
-    s.replace(0, 4, sv, 0, std::string::npos);   // calls replace(pos1, n1, T, pos, npos)
-    assert(s == sv);
+    S s0 = "ABCD";
+    S s;
+    SV sv = "EFGH";
+    char arr[] = "IJKL";
+
+    s = s0;
+    s.replace(0, 4, "CDEF", 0);    // calls replace(pos1, n1, const char *, len)
+    assert(s == "");
+
+    s = s0;
+    s.replace(0, 4, "QRST", 0, std::string::npos); // calls replace(pos1, n1, string("QRST"), pos, npos)
+    assert(s == "QRST");
+
+    s = s0;
+    s.replace(0, 4, sv, 0);  // calls replace(pos1, n1, T, pos, npos)
+    assert(s == sv);
+
+    s = s0;
+    s.replace(0, 4, sv, 0, std::string::npos);   // calls replace(pos1, n1, T, pos, npos)
+    assert(s == sv);
+
+    s = s0;
+    s.replace(0, 4, arr, 0);     // calls replace(pos1, n1, const char *, len)
+    assert(s == "");
+
+    s = s0;
+    s.replace(0, 4, arr, 0, std::string::npos);    // calls replace(pos1, n1, string("IJKL"), pos, npos)
+    assert(s == "IJKL");
+
+    return true;
+
+template <class S, class SV>
+bool test() {
 
-    s = s0;
-    s.replace(0, 4, arr, 0);     // calls replace(pos1, n1, const char *, len)
-    assert(s == "");
+#if TEST_STD_VER > 17
+  // static_assert(test0<S, SV>());
+  // static_assert(test1<S, SV>());
+  // static_assert(test2<S, SV>());
+  // static_assert(test3<S, SV>());
+  // static_assert(test4<S, SV>());
+  // static_assert(test5<S, SV>());
+  // static_assert(test6<S, SV>());
+  // static_assert(test7<S, SV>());
+  // static_assert(test8<S, SV>());
+  // static_assert(test9<S, SV>());
+  // static_assert(test10<S, SV>());
+  // static_assert(test11<S, SV>());
+  // static_assert(test12<S, SV>());
+  // static_assert(test13<S, SV>());
+  // static_assert(test14<S, SV>());
+  // static_assert(test15<S, SV>());
+  // static_assert(test16<S, SV>());
+  // static_assert(test17<S, SV>());
+  // static_assert(test18<S, SV>());
+  // static_assert(test19<S, SV>());
+  // static_assert(test20<S, SV>());
+  // static_assert(test21<S, SV>());
+  // static_assert(test22<S, SV>());
+  // static_assert(test23<S, SV>());
+  // static_assert(test24<S, SV>());
+  // static_assert(test25<S, SV>());
+  // static_assert(test26<S, SV>());
+  // static_assert(test27<S, SV>());
+  // static_assert(test28<S, SV>());
+  // static_assert(test29<S, SV>());
+  // static_assert(test30<S, SV>());
+  // static_assert(test31<S, SV>());
+  // static_assert(test32<S, SV>());
+  // static_assert(test33<S, SV>());
+  // static_assert(test34<S, SV>());
+  // static_assert(test35<S, SV>());
+  // static_assert(test36<S, SV>());
+  // static_assert(test37<S, SV>());
+  // static_assert(test38<S, SV>());
+  // static_assert(test39<S, SV>());
+  // static_assert(test40<S, SV>());
+  // static_assert(test41<S, SV>());
+  // static_assert(test42<S, SV>());
+  // static_assert(test43<S, SV>());
+  // static_assert(test44<S, SV>());
+  // static_assert(test45<S, SV>());
+  // static_assert(test46<S, SV>());
+  // static_assert(test47<S, SV>());
+  // static_assert(test48<S, SV>());
+  // static_assert(test49<S, SV>());
+  // static_assert(test50<S, SV>());
+  // static_assert(test51<S, SV>());
+  // static_assert(test52<S, SV>());
+  // static_assert(test53<S, SV>());
+  // static_assert(test54<S, SV>());
+  // static_assert(test55<S, SV>());
+#endif
 
-    s = s0;
-    s.replace(0, 4, arr, 0, std::string::npos);    // calls replace(pos1, n1, string("IJKL"), pos, npos)
-    assert(s == "IJKL");
-    }
+  return true;
 
+int main(int, char**)
+{
+  test<std::string, std::string_view>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>,
+       std::basic_string_view<char, std::char_traits<char>>>();
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.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 s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.replace(pos, n1, str);
else
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, "", S(""));
     test(S(""), 0, 0, "12345", S("12345"));
     test(S(""), 0, 0, "1234567890", S("1234567890"));
     test(S(""), 0, 0, "12345678901234567890", S("12345678901234567890"));
     test(S(""), 0, 1, "", S(""));
     test(S(""), 0, 1, "12345", S("12345"));
     test(S(""), 0, 1, "1234567890", S("1234567890"));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 5, 0, "12345678901234567890", S("abcde12345678901234567890"));
     test(S("abcde"), 5, 1, "", S("abcde"));
     test(S("abcde"), 5, 1, "12345", S("abcde12345"));
     test(S("abcde"), 5, 1, "1234567890", S("abcde1234567890"));
     test(S("abcde"), 5, 1, "12345678901234567890", S("abcde12345678901234567890"));
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, "", S("can't happen"));
     test(S("abcde"), 6, 0, "12345", S("can't happen"));
     test(S("abcde"), 6, 0, "1234567890", S("can't happen"));
     test(S("abcde"), 6, 0, "12345678901234567890", S("can't happen"));
     test(S("abcdefghij"), 0, 0, "", S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345", S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", S("1234567890abcdefghij"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghij"), 10, 1, "12345678901234567890", S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 11, 0, "", S("can't happen"));
     test(S("abcdefghij"), 11, 0, "12345", S("can't happen"));
     test(S("abcdefghij"), 11, 0, "1234567890", S("can't happen"));
     test(S("abcdefghij"), 11, 0, "12345678901234567890", S("can't happen"));
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, "", S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "12345", S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "1234567890", S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "12345678901234567890", S("12345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "", S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", S("1234567890bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghijklmnopqrst"), 20, 1, "1234567890", S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 1, "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "1234567890", S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", S("can't happen"));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.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 s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
else
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, "", 0, S(""));
     test(S(""), 0, 0, "12345", 0, S(""));
     test(S(""), 0, 0, "12345", 1, S("1"));
     test(S(""), 0, 0, "12345", 2, S("12"));
     test(S(""), 0, 0, "12345", 4, S("1234"));
     test(S(""), 0, 0, "12345", 5, S("12345"));
     test(S(""), 0, 0, "1234567890", 0, S(""));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S("abcde"), 0, 2, "12345678901234567890", 1, S("1cde"));
     test(S("abcde"), 0, 2, "12345678901234567890", 10, S("1234567890cde"));
     test(S("abcde"), 0, 2, "12345678901234567890", 19, S("1234567890123456789cde"));
     test(S("abcde"), 0, 2, "12345678901234567890", 20, S("12345678901234567890cde"));
     test(S("abcde"), 0, 4, "", 0, S("e"));
     test(S("abcde"), 0, 4, "12345", 0, S("e"));
     test(S("abcde"), 0, 4, "12345", 1, S("1e"));
     test(S("abcde"), 0, 4, "12345", 2, S("12e"));
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S("abcde"), 0, 4, "12345", 4, S("1234e"));
     test(S("abcde"), 0, 4, "12345", 5, S("12345e"));
     test(S("abcde"), 0, 4, "1234567890", 0, S("e"));
     test(S("abcde"), 0, 4, "1234567890", 1, S("1e"));
     test(S("abcde"), 0, 4, "1234567890", 5, S("12345e"));
     test(S("abcde"), 0, 4, "1234567890", 9, S("123456789e"));
     test(S("abcde"), 0, 4, "1234567890", 10, S("1234567890e"));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S("abcde"), 1, 3, "", 0, S("ae"));
     test(S("abcde"), 1, 3, "12345", 0, S("ae"));
     test(S("abcde"), 1, 3, "12345", 1, S("a1e"));
     test(S("abcde"), 1, 3, "12345", 2, S("a12e"));
     test(S("abcde"), 1, 3, "12345", 4, S("a1234e"));
     test(S("abcde"), 1, 3, "12345", 5, S("a12345e"));
     test(S("abcde"), 1, 3, "1234567890", 0, S("ae"));
     test(S("abcde"), 1, 3, "1234567890", 1, S("a1e"));
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S("abcde"), 1, 3, "1234567890", 5, S("a12345e"));
     test(S("abcde"), 1, 3, "1234567890", 9, S("a123456789e"));
     test(S("abcde"), 1, 3, "1234567890", 10, S("a1234567890e"));
     test(S("abcde"), 1, 3, "12345678901234567890", 0, S("ae"));
     test(S("abcde"), 1, 3, "12345678901234567890", 1, S("a1e"));
     test(S("abcde"), 1, 3, "12345678901234567890", 10, S("a1234567890e"));
     test(S("abcde"), 1, 3, "12345678901234567890", 19, S("a1234567890123456789e"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcde"), 2, 3, "12345", 4, S("ab1234"));
     test(S("abcde"), 2, 3, "12345", 5, S("ab12345"));
     test(S("abcde"), 2, 3, "1234567890", 0, S("ab"));
     test(S("abcde"), 2, 3, "1234567890", 1, S("ab1"));
     test(S("abcde"), 2, 3, "1234567890", 5, S("ab12345"));
     test(S("abcde"), 2, 3, "1234567890", 9, S("ab123456789"));
     test(S("abcde"), 2, 3, "1234567890", 10, S("ab1234567890"));
     test(S("abcde"), 2, 3, "12345678901234567890", 0, S("ab"));
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 2, 3, "12345678901234567890", 1, S("ab1"));
     test(S("abcde"), 2, 3, "12345678901234567890", 10, S("ab1234567890"));
     test(S("abcde"), 2, 3, "12345678901234567890", 19, S("ab1234567890123456789"));
     test(S("abcde"), 2, 3, "12345678901234567890", 20, S("ab12345678901234567890"));
     test(S("abcde"), 2, 4, "", 0, S("ab"));
     test(S("abcde"), 2, 4, "12345", 0, S("ab"));
     test(S("abcde"), 2, 4, "12345", 1, S("ab1"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 5, 1, "1234567890", 5, S("abcde12345"));
     test(S("abcde"), 5, 1, "1234567890", 9, S("abcde123456789"));
     test(S("abcde"), 5, 1, "1234567890", 10, S("abcde1234567890"));
     test(S("abcde"), 5, 1, "12345678901234567890", 0, S("abcde"));
     test(S("abcde"), 5, 1, "12345678901234567890", 1, S("abcde1"));
     test(S("abcde"), 5, 1, "12345678901234567890", 10, S("abcde1234567890"));
     test(S("abcde"), 5, 1, "12345678901234567890", 19, S("abcde1234567890123456789"));
     test(S("abcde"), 5, 1, "12345678901234567890", 20, S("abcde12345678901234567890"));
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 6, 0, "", 0, S("can't happen"));
     test(S("abcde"), 6, 0, "12345", 0, S("can't happen"));
     test(S("abcde"), 6, 0, "12345", 1, S("can't happen"));
     test(S("abcde"), 6, 0, "12345", 2, S("can't happen"));
     test(S("abcde"), 6, 0, "12345", 4, S("can't happen"));
     test(S("abcde"), 6, 0, "12345", 5, S("can't happen"));
     test(S("abcde"), 6, 0, "1234567890", 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcdefghij"), 0, 10, "12345678901234567890", 1, S("1"));
     test(S("abcdefghij"), 0, 10, "12345678901234567890", 10, S("1234567890"));
     test(S("abcdefghij"), 0, 10, "12345678901234567890", 19, S("1234567890123456789"));
     test(S("abcdefghij"), 0, 10, "12345678901234567890", 20, S("12345678901234567890"));
     test(S("abcdefghij"), 0, 11, "", 0, S(""));
     test(S("abcdefghij"), 0, 11, "12345", 0, S(""));
     test(S("abcdefghij"), 0, 11, "12345", 1, S("1"));
     test(S("abcdefghij"), 0, 11, "12345", 2, S("12"));
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcdefghij"), 0, 11, "12345", 4, S("1234"));
     test(S("abcdefghij"), 0, 11, "12345", 5, S("12345"));
     test(S("abcdefghij"), 0, 11, "1234567890", 0, S(""));
     test(S("abcdefghij"), 0, 11, "1234567890", 1, S("1"));
     test(S("abcdefghij"), 0, 11, "1234567890", 5, S("12345"));
     test(S("abcdefghij"), 0, 11, "1234567890", 9, S("123456789"));
     test(S("abcdefghij"), 0, 11, "1234567890", 10, S("1234567890"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcdefghij"), 1, 10, "", 0, S("a"));
     test(S("abcdefghij"), 1, 10, "12345", 0, S("a"));
     test(S("abcdefghij"), 1, 10, "12345", 1, S("a1"));
     test(S("abcdefghij"), 1, 10, "12345", 2, S("a12"));
     test(S("abcdefghij"), 1, 10, "12345", 4, S("a1234"));
     test(S("abcdefghij"), 1, 10, "12345", 5, S("a12345"));
     test(S("abcdefghij"), 1, 10, "1234567890", 0, S("a"));
     test(S("abcdefghij"), 1, 10, "1234567890", 1, S("a1"));
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcdefghij"), 1, 10, "1234567890", 5, S("a12345"));
     test(S("abcdefghij"), 1, 10, "1234567890", 9, S("a123456789"));
     test(S("abcdefghij"), 1, 10, "1234567890", 10, S("a1234567890"));
     test(S("abcdefghij"), 1, 10, "12345678901234567890", 0, S("a"));
     test(S("abcdefghij"), 1, 10, "12345678901234567890", 1, S("a1"));
     test(S("abcdefghij"), 1, 10, "12345678901234567890", 10, S("a1234567890"));
     test(S("abcdefghij"), 1, 10, "12345678901234567890", 19, S("a1234567890123456789"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcdefghij"), 5, 6, "12345", 4, S("abcde1234"));
     test(S("abcdefghij"), 5, 6, "12345", 5, S("abcde12345"));
     test(S("abcdefghij"), 5, 6, "1234567890", 0, S("abcde"));
     test(S("abcdefghij"), 5, 6, "1234567890", 1, S("abcde1"));
     test(S("abcdefghij"), 5, 6, "1234567890", 5, S("abcde12345"));
     test(S("abcdefghij"), 5, 6, "1234567890", 9, S("abcde123456789"));
     test(S("abcdefghij"), 5, 6, "1234567890", 10, S("abcde1234567890"));
     test(S("abcdefghij"), 5, 6, "12345678901234567890", 0, S("abcde"));
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcdefghij"), 5, 6, "12345678901234567890", 1, S("abcde1"));
     test(S("abcdefghij"), 5, 6, "12345678901234567890", 10, S("abcde1234567890"));
     test(S("abcdefghij"), 5, 6, "12345678901234567890", 19, S("abcde1234567890123456789"));
     test(S("abcdefghij"), 5, 6, "12345678901234567890", 20, S("abcde12345678901234567890"));
     test(S("abcdefghij"), 9, 0, "", 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, "12345", 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, "12345", 1, S("abcdefghi1j"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcdefghij"), 11, 0, "1234567890", 5, S("can't happen"));
     test(S("abcdefghij"), 11, 0, "1234567890", 9, S("can't happen"));
     test(S("abcdefghij"), 11, 0, "1234567890", 10, S("can't happen"));
     test(S("abcdefghij"), 11, 0, "12345678901234567890", 0, S("can't happen"));
     test(S("abcdefghij"), 11, 0, "12345678901234567890", 1, S("can't happen"));
     test(S("abcdefghij"), 11, 0, "12345678901234567890", 10, S("can't happen"));
     test(S("abcdefghij"), 11, 0, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghij"), 11, 0, "12345678901234567890", 20, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, "", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "12345", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "12345", 1, S("1abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "12345", 2, S("12abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "12345", 4, S("1234abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "12345", 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, "1234567890", 0, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcdefghijklmnopqrst"), 0, 21, "12345678901234567890", 1, S("1"));
     test(S("abcdefghijklmnopqrst"), 0, 21, "12345678901234567890", 10, S("1234567890"));
     test(S("abcdefghijklmnopqrst"), 0, 21, "12345678901234567890", 19, S("1234567890123456789"));
     test(S("abcdefghijklmnopqrst"), 0, 21, "12345678901234567890", 20, S("12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "12345", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "12345", 1, S("a1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "12345", 2, S("a12bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, "12345", 4, S("a1234bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "12345", 5, S("a12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "1234567890", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "1234567890", 1, S("a1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "1234567890", 5, S("a12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "1234567890", 9, S("a123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, "1234567890", 10, S("a1234567890bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcdefghijklmnopqrst"), 10, 0, "", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345", 1, S("abcdefghij1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345", 2, S("abcdefghij12klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345", 4, S("abcdefghij1234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345", 5, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "1234567890", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "1234567890", 1, S("abcdefghij1klmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, "1234567890", 5, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "1234567890", 9, S("abcdefghij123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "1234567890", 10, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345678901234567890", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345678901234567890", 1, S("abcdefghij1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345678901234567890", 10, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, "12345678901234567890", 19, S("abcdefghij1234567890123456789klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345", 4, S("abcdefghijklmnopqrs1234t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345", 5, S("abcdefghijklmnopqrs12345t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "1234567890", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "1234567890", 1, S("abcdefghijklmnopqrs1t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "1234567890", 5, S("abcdefghijklmnopqrs12345t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "1234567890", 9, S("abcdefghijklmnopqrs123456789t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "1234567890", 10, S("abcdefghijklmnopqrs1234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345678901234567890", 0, S("abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345678901234567890", 1, S("abcdefghijklmnopqrs1t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345678901234567890", 10, S("abcdefghijklmnopqrs1234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345678901234567890", 19, S("abcdefghijklmnopqrs1234567890123456789t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, "12345678901234567890", 20, S("abcdefghijklmnopqrs12345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 1, "", 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 1, "12345", 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 1, "12345", 1, S("abcdefghijklmnopqrs1"));
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcdefghijklmnopqrst"), 21, 0, "1234567890", 5, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "1234567890", 9, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "1234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", 20, S("can't happen"));
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    }
+template <class S>
+void test() {
+
+#if TEST_STD_VER > 17
+  // static_assert(test0<S>());
+  // static_assert(test1<S>());
+  // static_assert(test2<S>());
+  // static_assert(test3<S>());
+  // static_assert(test4<S>());
+  // static_assert(test5<S>());
+  // static_assert(test6<S>());
+  // static_assert(test7<S>());
+  // static_assert(test8<S>());
+  // static_assert(test9<S>());
+  // static_assert(test10<S>());
+  // static_assert(test11<S>());
+#endif
+
+int main(int, char**)
+  test<std::string>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.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 s, typename S::size_type pos, typename S::size_type n1,
      typename S::size_type n2, typename S::value_type c,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
else
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, 0, '2', S(""));
     test(S(""), 0, 0, 5, '2', S("22222"));
     test(S(""), 0, 0, 10, '2', S("2222222222"));
     test(S(""), 0, 0, 20, '2', S("22222222222222222222"));
     test(S(""), 0, 1, 0, '2', S(""));
     test(S(""), 0, 1, 5, '2', S("22222"));
     test(S(""), 0, 1, 10, '2', S("2222222222"));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 5, 0, 20, '2', S("abcde22222222222222222222"));
     test(S("abcde"), 5, 1, 0, '2', S("abcde"));
     test(S("abcde"), 5, 1, 5, '2', S("abcde22222"));
     test(S("abcde"), 5, 1, 10, '2', S("abcde2222222222"));
     test(S("abcde"), 5, 1, 20, '2', S("abcde22222222222222222222"));
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, 0, '2', S("can't happen"));
     test(S("abcde"), 6, 0, 5, '2', S("can't happen"));
     test(S("abcde"), 6, 0, 10, '2', S("can't happen"));
     test(S("abcde"), 6, 0, 20, '2', S("can't happen"));
     test(S("abcdefghij"), 0, 0, 0, '2', S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, 5, '2', S("22222abcdefghij"));
     test(S("abcdefghij"), 0, 0, 10, '2', S("2222222222abcdefghij"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghij"), 10, 1, 20, '2', S("abcdefghij22222222222222222222"));
     test(S("abcdefghij"), 11, 0, 0, '2', S("can't happen"));
     test(S("abcdefghij"), 11, 0, 5, '2', S("can't happen"));
     test(S("abcdefghij"), 11, 0, 10, '2', S("can't happen"));
     test(S("abcdefghij"), 11, 0, 20, '2', S("can't happen"));
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, 0, '2', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, 5, '2', S("22222abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, 10, '2', S("2222222222abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, 20, '2', S("22222222222222222222abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, 0, '2', S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, 5, '2', S("22222bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, 10, '2', S("2222222222bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghijklmnopqrst"), 20, 1, 10, '2', S("abcdefghijklmnopqrst2222222222"));
     test(S("abcdefghijklmnopqrst"), 20, 1, 20, '2', S("abcdefghijklmnopqrst22222222222222222222"));
     test(S("abcdefghijklmnopqrst"), 21, 0, 0, '2', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, 5, '2', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, 10, '2', S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, 20, '2', S("can't happen"));
 }
 
-int main(int, char**)
-{
+bool test() {
     {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.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 s, typename S::size_type pos1, typename S::size_type n1, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
     {
         s.replace(pos1, n1, str);
         LIBCPP_ASSERT(s.__invariants());
else
             assert(pos1 > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, S(""), S(""));
     test(S(""), 0, 0, S("12345"), S("12345"));
     test(S(""), 0, 0, S("1234567890"), S("1234567890"));
     test(S(""), 0, 0, S("12345678901234567890"), S("12345678901234567890"));
     test(S(""), 0, 1, S(""), S(""));
     test(S(""), 0, 1, S("12345"), S("12345"));
     test(S(""), 0, 1, S("1234567890"), S("1234567890"));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 5, 0, S("12345678901234567890"), S("abcde12345678901234567890"));
     test(S("abcde"), 5, 1, S(""), S("abcde"));
     test(S("abcde"), 5, 1, S("12345"), S("abcde12345"));
     test(S("abcde"), 5, 1, S("1234567890"), S("abcde1234567890"));
     test(S("abcde"), 5, 1, S("12345678901234567890"), S("abcde12345678901234567890"));
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, S(""), S("can't happen"));
     test(S("abcde"), 6, 0, S("12345"), S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), S("can't happen"));
     test(S("abcde"), 6, 0, S("12345678901234567890"), S("can't happen"));
     test(S("abcdefghij"), 0, 0, S(""), S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, S("12345"), S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, S("1234567890"), S("1234567890abcdefghij"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghij"), 10, 1, S("12345678901234567890"), S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 11, 0, S(""), S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345"), S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("1234567890"), S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), S("can't happen"));
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S("12345"), S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S("1234567890"), S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S(""), S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), S("1234567890bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghijklmnopqrst"), 20, 1, S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), S("can't happen"));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
     test2<S>();
-    }
 #endif
 
 #if TEST_STD_VER > 3
-    {   // LWG 2946
+  { // LWG 2946
     std::string s = " ";
     s.replace(0, 1, {"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.modifiers/string_replace/size_size_string_size_size.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 s, typename S::size_type pos1, typename S::size_type n1,
      S str, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
else
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, typename S::size_type pos1, typename S::size_type n1,
      S str, typename S::size_type pos2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
else
             assert(s == s0);
         }
     }
 #endif
 }
 
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, S(""), 0, 0, S(""));
     test(S(""), 0, 0, S(""), 0, 1, S(""));
     test(S(""), 0, 0, S(""), 1, 0, S("can't happen"));
     test(S(""), 0, 0, S("12345"), 0, 0, S(""));
     test(S(""), 0, 0, S("12345"), 0, 1, S("1"));
     test(S(""), 0, 0, S("12345"), 0, 2, S("12"));
     test(S(""), 0, 0, S("12345"), 0, 4, S("1234"));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, 1, S("12345"), 2, 3, S("345"));
     test(S(""), 0, 1, S("12345"), 2, 4, S("345"));
     test(S(""), 0, 1, S("12345"), 4, 0, S(""));
     test(S(""), 0, 1, S("12345"), 4, 1, S("5"));
     test(S(""), 0, 1, S("12345"), 4, 2, S("5"));
     test(S(""), 0, 1, S("12345"), 5, 0, S(""));
     test(S(""), 0, 1, S("12345"), 5, 1, S(""));
     test(S(""), 0, 1, S("12345"), 6, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, 1, S("1234567890"), 0, 0, S(""));
     test(S(""), 0, 1, S("1234567890"), 0, 1, S("1"));
     test(S(""), 0, 1, S("1234567890"), 0, 5, S("12345"));
     test(S(""), 0, 1, S("1234567890"), 0, 9, S("123456789"));
     test(S(""), 0, 1, S("1234567890"), 0, 10, S("1234567890"));
     test(S(""), 0, 1, S("1234567890"), 0, 11, S("1234567890"));
     test(S(""), 0, 1, S("1234567890"), 1, 0, S(""));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, 0, S("1234567890"), 9, 0, S("can't happen"));
     test(S(""), 1, 0, S("1234567890"), 9, 1, S("can't happen"));
     test(S(""), 1, 0, S("1234567890"), 9, 2, S("can't happen"));
     test(S(""), 1, 0, S("1234567890"), 10, 0, S("can't happen"));
     test(S(""), 1, 0, S("1234567890"), 10, 1, S("can't happen"));
     test(S(""), 1, 0, S("1234567890"), 11, 0, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 0, 0, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 0, 1, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, 0, S("12345678901234567890"), 0, 10, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 0, 19, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 0, 20, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 0, 21, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 1, 0, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 1, 1, S("can't happen"));
     test(S(""), 1, 0, S("12345678901234567890"), 1, 9, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcde"), 0, 0, S("12345678901234567890"), 19, 2, S("0abcde"));
     test(S("abcde"), 0, 0, S("12345678901234567890"), 20, 0, S("abcde"));
     test(S("abcde"), 0, 0, S("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 0, 0, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 0, 1, S(""), 0, 0, S("bcde"));
     test(S("abcde"), 0, 1, S(""), 0, 1, S("bcde"));
     test(S("abcde"), 0, 1, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, 1, S("12345"), 0, 0, S("bcde"));
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, 1, S("12345"), 0, 1, S("1bcde"));
     test(S("abcde"), 0, 1, S("12345"), 0, 2, S("12bcde"));
     test(S("abcde"), 0, 1, S("12345"), 0, 4, S("1234bcde"));
     test(S("abcde"), 0, 1, S("12345"), 0, 5, S("12345bcde"));
     test(S("abcde"), 0, 1, S("12345"), 0, 6, S("12345bcde"));
     test(S("abcde"), 0, 1, S("12345"), 1, 0, S("bcde"));
     test(S("abcde"), 0, 1, S("12345"), 1, 1, S("2bcde"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, 2, S("12345"), 4, 2, S("5cde"));
     test(S("abcde"), 0, 2, S("12345"), 5, 0, S("cde"));
     test(S("abcde"), 0, 2, S("12345"), 5, 1, S("cde"));
     test(S("abcde"), 0, 2, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 0, 2, S("1234567890"), 0, 0, S("cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 0, 1, S("1cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 0, 5, S("12345cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 0, 9, S("123456789cde"));
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, 2, S("1234567890"), 0, 10, S("1234567890cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 0, 11, S("1234567890cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 1, 0, S("cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 1, 1, S("2cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 1, 4, S("2345cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 1, 8, S("23456789cde"));
     test(S("abcde"), 0, 2, S("1234567890"), 1, 9, S("234567890cde"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 0, 4, S("1234567890"), 10, 1, S("e"));
     test(S("abcde"), 0, 4, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 0, 0, S("e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 0, 1, S("1e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 0, 10, S("1234567890e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 0, 19, S("1234567890123456789e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 0, 20, S("12345678901234567890e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 0, 21, S("12345678901234567890e"));
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 0, 4, S("12345678901234567890"), 1, 0, S("e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 1, 1, S("2e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 1, 9, S("234567890e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 1, 18, S("234567890123456789e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 1, 19, S("2345678901234567890e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 1, 20, S("2345678901234567890e"));
     test(S("abcde"), 0, 4, S("12345678901234567890"), 10, 0, S("e"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 0, 6, S(""), 0, 0, S(""));
     test(S("abcde"), 0, 6, S(""), 0, 1, S(""));
     test(S("abcde"), 0, 6, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, 6, S("12345"), 0, 0, S(""));
     test(S("abcde"), 0, 6, S("12345"), 0, 1, S("1"));
     test(S("abcde"), 0, 6, S("12345"), 0, 2, S("12"));
     test(S("abcde"), 0, 6, S("12345"), 0, 4, S("1234"));
     test(S("abcde"), 0, 6, S("12345"), 0, 5, S("12345"));
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 0, 6, S("12345"), 0, 6, S("12345"));
     test(S("abcde"), 0, 6, S("12345"), 1, 0, S(""));
     test(S("abcde"), 0, 6, S("12345"), 1, 1, S("2"));
     test(S("abcde"), 0, 6, S("12345"), 1, 2, S("23"));
     test(S("abcde"), 0, 6, S("12345"), 1, 3, S("234"));
     test(S("abcde"), 0, 6, S("12345"), 1, 4, S("2345"));
     test(S("abcde"), 0, 6, S("12345"), 1, 5, S("2345"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 1, 0, S("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 0, 1, S("a1bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 0, 5, S("a12345bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 0, 9, S("a123456789bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 0, 10, S("a1234567890bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 0, 11, S("a1234567890bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 1, 1, S("a2bcde"));
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 1, 0, S("1234567890"), 1, 4, S("a2345bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 1, 8, S("a23456789bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 1, 9, S("a234567890bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 1, 10, S("a234567890bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 5, 0, S("abcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 5, 1, S("a6bcde"));
     test(S("abcde"), 1, 0, S("1234567890"), 5, 2, S("a67bcde"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 1, 1, S("12345678901234567890"), 0, 10, S("a1234567890cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 0, 19, S("a1234567890123456789cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 0, 20, S("a12345678901234567890cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 0, 21, S("a12345678901234567890cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 1, 0, S("acde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 1, 1, S("a2cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 1, 9, S("a234567890cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 1, 18, S("a234567890123456789cde"));
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 1, 1, S("12345678901234567890"), 1, 19, S("a2345678901234567890cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 1, 20, S("a2345678901234567890cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 10, 0, S("acde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 10, 1, S("a1cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 10, 5, S("a12345cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 10, 9, S("a123456789cde"));
     test(S("abcde"), 1, 1, S("12345678901234567890"), 10, 10, S("a1234567890cde"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 1, 3, S("12345"), 0, 1, S("a1e"));
     test(S("abcde"), 1, 3, S("12345"), 0, 2, S("a12e"));
     test(S("abcde"), 1, 3, S("12345"), 0, 4, S("a1234e"));
     test(S("abcde"), 1, 3, S("12345"), 0, 5, S("a12345e"));
     test(S("abcde"), 1, 3, S("12345"), 0, 6, S("a12345e"));
     test(S("abcde"), 1, 3, S("12345"), 1, 0, S("ae"));
     test(S("abcde"), 1, 3, S("12345"), 1, 1, S("a2e"));
     test(S("abcde"), 1, 3, S("12345"), 1, 2, S("a23e"));
+
+    return true;
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 1, 3, S("12345"), 1, 3, S("a234e"));
     test(S("abcde"), 1, 3, S("12345"), 1, 4, S("a2345e"));
     test(S("abcde"), 1, 3, S("12345"), 1, 5, S("a2345e"));
     test(S("abcde"), 1, 3, S("12345"), 2, 0, S("ae"));
     test(S("abcde"), 1, 3, S("12345"), 2, 1, S("a3e"));
     test(S("abcde"), 1, 3, S("12345"), 2, 2, S("a34e"));
     test(S("abcde"), 1, 3, S("12345"), 2, 3, S("a345e"));
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 1, 4, S("1234567890"), 0, 10, S("a1234567890"));
     test(S("abcde"), 1, 4, S("1234567890"), 0, 11, S("a1234567890"));
     test(S("abcde"), 1, 4, S("1234567890"), 1, 0, S("a"));
     test(S("abcde"), 1, 4, S("1234567890"), 1, 1, S("a2"));
     test(S("abcde"), 1, 4, S("1234567890"), 1, 4, S("a2345"));
     test(S("abcde"), 1, 4, S("1234567890"), 1, 8, S("a23456789"));
     test(S("abcde"), 1, 4, S("1234567890"), 1, 9, S("a234567890"));
     test(S("abcde"), 1, 4, S("1234567890"), 1, 10, S("a234567890"));
+
+    return true;
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 1, 4, S("1234567890"), 5, 0, S("a"));
     test(S("abcde"), 1, 4, S("1234567890"), 5, 1, S("a6"));
     test(S("abcde"), 1, 4, S("1234567890"), 5, 2, S("a67"));
     test(S("abcde"), 1, 4, S("1234567890"), 5, 4, S("a6789"));
     test(S("abcde"), 1, 4, S("1234567890"), 5, 5, S("a67890"));
     test(S("abcde"), 1, 4, S("1234567890"), 5, 6, S("a67890"));
     test(S("abcde"), 1, 4, S("1234567890"), 9, 0, S("a"));
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 1, 5, S("12345678901234567890"), 1, 0, S("a"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 1, 1, S("a2"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 1, 9, S("a234567890"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 1, 18, S("a234567890123456789"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 1, 19, S("a2345678901234567890"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 1, 20, S("a2345678901234567890"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 10, 0, S("a"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 10, 1, S("a1"));
+
+    return true;
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcde"), 1, 5, S("12345678901234567890"), 10, 5, S("a12345"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 10, 9, S("a123456789"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 10, 10, S("a1234567890"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 10, 11, S("a1234567890"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 19, 0, S("a"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 19, 1, S("a0"));
     test(S("abcde"), 1, 5, S("12345678901234567890"), 19, 2, S("a0"));
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcde"), 2, 1, S("12345"), 0, 6, S("ab12345de"));
     test(S("abcde"), 2, 1, S("12345"), 1, 0, S("abde"));
     test(S("abcde"), 2, 1, S("12345"), 1, 1, S("ab2de"));
     test(S("abcde"), 2, 1, S("12345"), 1, 2, S("ab23de"));
     test(S("abcde"), 2, 1, S("12345"), 1, 3, S("ab234de"));
     test(S("abcde"), 2, 1, S("12345"), 1, 4, S("ab2345de"));
     test(S("abcde"), 2, 1, S("12345"), 1, 5, S("ab2345de"));
     test(S("abcde"), 2, 1, S("12345"), 2, 0, S("abde"));
+
+    return true;
 }
 
 template <class S>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcde"), 2, 1, S("12345"), 2, 1, S("ab3de"));
     test(S("abcde"), 2, 1, S("12345"), 2, 2, S("ab34de"));
     test(S("abcde"), 2, 1, S("12345"), 2, 3, S("ab345de"));
     test(S("abcde"), 2, 1, S("12345"), 2, 4, S("ab345de"));
     test(S("abcde"), 2, 1, S("12345"), 4, 0, S("abde"));
     test(S("abcde"), 2, 1, S("12345"), 4, 1, S("ab5de"));
     test(S("abcde"), 2, 1, S("12345"), 4, 2, S("ab5de"));
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcde"), 2, 2, S("1234567890"), 1, 4, S("ab2345e"));
     test(S("abcde"), 2, 2, S("1234567890"), 1, 8, S("ab23456789e"));
     test(S("abcde"), 2, 2, S("1234567890"), 1, 9, S("ab234567890e"));
     test(S("abcde"), 2, 2, S("1234567890"), 1, 10, S("ab234567890e"));
     test(S("abcde"), 2, 2, S("1234567890"), 5, 0, S("abe"));
     test(S("abcde"), 2, 2, S("1234567890"), 5, 1, S("ab6e"));
     test(S("abcde"), 2, 2, S("1234567890"), 5, 2, S("ab67e"));
     test(S("abcde"), 2, 2, S("1234567890"), 5, 4, S("ab6789e"));
+
+    return true;
 }
 
 template <class S>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcde"), 2, 2, S("1234567890"), 5, 5, S("ab67890e"));
     test(S("abcde"), 2, 2, S("1234567890"), 5, 6, S("ab67890e"));
     test(S("abcde"), 2, 2, S("1234567890"), 9, 0, S("abe"));
     test(S("abcde"), 2, 2, S("1234567890"), 9, 1, S("ab0e"));
     test(S("abcde"), 2, 2, S("1234567890"), 9, 2, S("ab0e"));
     test(S("abcde"), 2, 2, S("1234567890"), 10, 0, S("abe"));
     test(S("abcde"), 2, 2, S("1234567890"), 10, 1, S("abe"));
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcde"), 2, 3, S("12345678901234567890"), 1, 19, S("ab2345678901234567890"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 1, 20, S("ab2345678901234567890"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 10, 0, S("ab"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 10, 1, S("ab1"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 10, 5, S("ab12345"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 10, 9, S("ab123456789"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 10, 10, S("ab1234567890"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 10, 11, S("ab1234567890"));
+
+    return true;
 }
 
 template <class S>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcde"), 2, 3, S("12345678901234567890"), 19, 0, S("ab"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 19, 1, S("ab0"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 19, 2, S("ab0"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 20, 0, S("ab"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 20, 1, S("ab"));
     test(S("abcde"), 2, 3, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 2, 4, S(""), 0, 0, S("ab"));
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcde"), 4, 0, S("12345"), 1, 3, S("abcd234e"));
     test(S("abcde"), 4, 0, S("12345"), 1, 4, S("abcd2345e"));
     test(S("abcde"), 4, 0, S("12345"), 1, 5, S("abcd2345e"));
     test(S("abcde"), 4, 0, S("12345"), 2, 0, S("abcde"));
     test(S("abcde"), 4, 0, S("12345"), 2, 1, S("abcd3e"));
     test(S("abcde"), 4, 0, S("12345"), 2, 2, S("abcd34e"));
     test(S("abcde"), 4, 0, S("12345"), 2, 3, S("abcd345e"));
     test(S("abcde"), 4, 0, S("12345"), 2, 4, S("abcd345e"));
+
+    return true;
 }
 
 template <class S>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcde"), 4, 0, S("12345"), 4, 0, S("abcde"));
     test(S("abcde"), 4, 0, S("12345"), 4, 1, S("abcd5e"));
     test(S("abcde"), 4, 0, S("12345"), 4, 2, S("abcd5e"));
     test(S("abcde"), 4, 0, S("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 4, 0, S("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 4, 0, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 4, 0, S("1234567890"), 0, 0, S("abcde"));
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcde"), 4, 1, S("1234567890"), 5, 0, S("abcd"));
     test(S("abcde"), 4, 1, S("1234567890"), 5, 1, S("abcd6"));
     test(S("abcde"), 4, 1, S("1234567890"), 5, 2, S("abcd67"));
     test(S("abcde"), 4, 1, S("1234567890"), 5, 4, S("abcd6789"));
     test(S("abcde"), 4, 1, S("1234567890"), 5, 5, S("abcd67890"));
     test(S("abcde"), 4, 1, S("1234567890"), 5, 6, S("abcd67890"));
     test(S("abcde"), 4, 1, S("1234567890"), 9, 0, S("abcd"));
     test(S("abcde"), 4, 1, S("1234567890"), 9, 1, S("abcd0"));
+
+    return true;
 }
 
 template <class S>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcde"), 4, 1, S("1234567890"), 9, 2, S("abcd0"));
     test(S("abcde"), 4, 1, S("1234567890"), 10, 0, S("abcd"));
     test(S("abcde"), 4, 1, S("1234567890"), 10, 1, S("abcd"));
     test(S("abcde"), 4, 1, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 4, 1, S("12345678901234567890"), 0, 0, S("abcd"));
     test(S("abcde"), 4, 1, S("12345678901234567890"), 0, 1, S("abcd1"));
     test(S("abcde"), 4, 1, S("12345678901234567890"), 0, 10, S("abcd1234567890"));
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcde"), 4, 2, S("12345678901234567890"), 10, 5, S("abcd12345"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 10, 9, S("abcd123456789"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 10, 10, S("abcd1234567890"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 10, 11, S("abcd1234567890"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 19, 0, S("abcd"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 19, 1, S("abcd0"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 19, 2, S("abcd0"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 20, 0, S("abcd"));
+
+    return true;
 }
 
 template <class S>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcde"), 4, 2, S("12345678901234567890"), 20, 1, S("abcd"));
     test(S("abcde"), 4, 2, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 5, 0, S(""), 0, 0, S("abcde"));
     test(S("abcde"), 5, 0, S(""), 0, 1, S("abcde"));
     test(S("abcde"), 5, 0, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 5, 0, S("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 5, 0, S("12345"), 0, 1, S("abcde1"));
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcde"), 5, 1, S("12345"), 2, 1, S("abcde3"));
     test(S("abcde"), 5, 1, S("12345"), 2, 2, S("abcde34"));
     test(S("abcde"), 5, 1, S("12345"), 2, 3, S("abcde345"));
     test(S("abcde"), 5, 1, S("12345"), 2, 4, S("abcde345"));
     test(S("abcde"), 5, 1, S("12345"), 4, 0, S("abcde"));
     test(S("abcde"), 5, 1, S("12345"), 4, 1, S("abcde5"));
     test(S("abcde"), 5, 1, S("12345"), 4, 2, S("abcde5"));
     test(S("abcde"), 5, 1, S("12345"), 5, 0, S("abcde"));
+
+    return true;
 }
 
 template <class S>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcde"), 5, 1, S("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 5, 1, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 5, 1, S("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 5, 1, S("1234567890"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, 1, S("1234567890"), 0, 5, S("abcde12345"));
     test(S("abcde"), 5, 1, S("1234567890"), 0, 9, S("abcde123456789"));
     test(S("abcde"), 5, 1, S("1234567890"), 0, 10, S("abcde1234567890"));
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcde"), 6, 0, S("1234567890"), 5, 5, S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), 5, 6, S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), 9, 0, S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), 9, 1, S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), 9, 2, S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), 10, 0, S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), 10, 1, S("can't happen"));
     test(S("abcde"), 6, 0, S("1234567890"), 11, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcde"), 6, 0, S("12345678901234567890"), 0, 0, S("can't happen"));
     test(S("abcde"), 6, 0, S("12345678901234567890"), 0, 1, S("can't happen"));
     test(S("abcde"), 6, 0, S("12345678901234567890"), 0, 10, S("can't happen"));
     test(S("abcde"), 6, 0, S("12345678901234567890"), 0, 19, S("can't happen"));
     test(S("abcde"), 6, 0, S("12345678901234567890"), 0, 20, S("can't happen"));
     test(S("abcde"), 6, 0, S("12345678901234567890"), 0, 21, S("can't happen"));
     test(S("abcde"), 6, 0, S("12345678901234567890"), 1, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 0, 0, S("12345678901234567890"), 19, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, S("12345678901234567890"), 19, 1, S("0abcdefghij"));
     test(S("abcdefghij"), 0, 0, S("12345678901234567890"), 19, 2, S("0abcdefghij"));
     test(S("abcdefghij"), 0, 0, S("12345678901234567890"), 20, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, S("12345678901234567890"), 20, 1, S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 1, S(""), 0, 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, S(""), 0, 1, S("bcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test20()
+TEST_CONSTEXPR_CXX20 bool test20()
 {
     test(S("abcdefghij"), 0, 1, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 1, S("12345"), 0, 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, S("12345"), 0, 1, S("1bcdefghij"));
     test(S("abcdefghij"), 0, 1, S("12345"), 0, 2, S("12bcdefghij"));
     test(S("abcdefghij"), 0, 1, S("12345"), 0, 4, S("1234bcdefghij"));
     test(S("abcdefghij"), 0, 1, S("12345"), 0, 5, S("12345bcdefghij"));
     test(S("abcdefghij"), 0, 1, S("12345"), 0, 6, S("12345bcdefghij"));
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghij"), 0, 5, S("12345"), 4, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, S("12345"), 4, 1, S("5fghij"));
     test(S("abcdefghij"), 0, 5, S("12345"), 4, 2, S("5fghij"));
     test(S("abcdefghij"), 0, 5, S("12345"), 5, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, S("12345"), 5, 1, S("fghij"));
     test(S("abcdefghij"), 0, 5, S("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 0, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 0, 1, S("1fghij"));
+
+    return true;
 }
 
 template <class S>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghij"), 0, 5, S("1234567890"), 0, 5, S("12345fghij"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 0, 9, S("123456789fghij"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 0, 10, S("1234567890fghij"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 0, 11, S("1234567890fghij"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 1, 0, S("fghij"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 1, 1, S("2fghij"));
     test(S("abcdefghij"), 0, 5, S("1234567890"), 1, 4, S("2345fghij"));
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghij"), 0, 9, S("1234567890"), 9, 2, S("0j"));
     test(S("abcdefghij"), 0, 9, S("1234567890"), 10, 0, S("j"));
     test(S("abcdefghij"), 0, 9, S("1234567890"), 10, 1, S("j"));
     test(S("abcdefghij"), 0, 9, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 0, 0, S("j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 0, 1, S("1j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 0, 10, S("1234567890j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 0, 19, S("1234567890123456789j"));
+
+    return true;
 }
 
 template <class S>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 0, 20, S("12345678901234567890j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 0, 21, S("12345678901234567890j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 1, 0, S("j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 1, 1, S("2j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 1, 9, S("234567890j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 1, 18, S("234567890123456789j"));
     test(S("abcdefghij"), 0, 9, S("12345678901234567890"), 1, 19, S("2345678901234567890j"));
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghij"), 0, 10, S("12345678901234567890"), 20, 1, S(""));
     test(S("abcdefghij"), 0, 10, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 11, S(""), 0, 0, S(""));
     test(S("abcdefghij"), 0, 11, S(""), 0, 1, S(""));
     test(S("abcdefghij"), 0, 11, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 0, 11, S("12345"), 0, 0, S(""));
     test(S("abcdefghij"), 0, 11, S("12345"), 0, 1, S("1"));
     test(S("abcdefghij"), 0, 11, S("12345"), 0, 2, S("12"));
+
+    return true;
 }
 
 template <class S>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghij"), 0, 11, S("12345"), 0, 4, S("1234"));
     test(S("abcdefghij"), 0, 11, S("12345"), 0, 5, S("12345"));
     test(S("abcdefghij"), 0, 11, S("12345"), 0, 6, S("12345"));
     test(S("abcdefghij"), 0, 11, S("12345"), 1, 0, S(""));
     test(S("abcdefghij"), 0, 11, S("12345"), 1, 1, S("2"));
     test(S("abcdefghij"), 0, 11, S("12345"), 1, 2, S("23"));
     test(S("abcdefghij"), 0, 11, S("12345"), 1, 3, S("234"));
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghij"), 1, 0, S("12345"), 5, 1, S("abcdefghij"));
     test(S("abcdefghij"), 1, 0, S("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 0, 1, S("a1bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 0, 5, S("a12345bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 0, 9, S("a123456789bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 0, 10, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 0, 11, S("a1234567890bcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghij"), 1, 0, S("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 1, 1, S("a2bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 1, 4, S("a2345bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 1, 8, S("a23456789bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 1, 9, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 1, 10, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, 0, S("1234567890"), 5, 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 0, 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 0, 1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 0, 10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 0, 19, S("a1234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 0, 20, S("a12345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 0, 21, S("a12345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 1, 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 1, 1, S("a2cdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 1, 9, S("a234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 1, 18, S("a234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 1, 19, S("a2345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 1, 20, S("a2345678901234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 10, 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 10, 1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, S("12345678901234567890"), 10, 5, S("a12345cdefghij"));
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghij"), 1, 8, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 1, 8, S("12345"), 0, 0, S("aj"));
     test(S("abcdefghij"), 1, 8, S("12345"), 0, 1, S("a1j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 0, 2, S("a12j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 0, 4, S("a1234j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 0, 5, S("a12345j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 0, 6, S("a12345j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 1, 0, S("aj"));
+
+    return true;
 }
 
 template <class S>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghij"), 1, 8, S("12345"), 1, 1, S("a2j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 1, 2, S("a23j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 1, 3, S("a234j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 1, 4, S("a2345j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 1, 5, S("a2345j"));
     test(S("abcdefghij"), 1, 8, S("12345"), 2, 0, S("aj"));
     test(S("abcdefghij"), 1, 8, S("12345"), 2, 1, S("a3j"));
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghij"), 1, 9, S("1234567890"), 0, 5, S("a12345"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 0, 9, S("a123456789"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 0, 10, S("a1234567890"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 0, 11, S("a1234567890"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 1, 0, S("a"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 1, 1, S("a2"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 1, 4, S("a2345"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 1, 8, S("a23456789"));
+
+    return true;
 }
 
 template <class S>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghij"), 1, 9, S("1234567890"), 1, 9, S("a234567890"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 1, 10, S("a234567890"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 5, 0, S("a"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 5, 1, S("a6"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 5, 2, S("a67"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 5, 4, S("a6789"));
     test(S("abcdefghij"), 1, 9, S("1234567890"), 5, 5, S("a67890"));
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 0, 20, S("a12345678901234567890"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 0, 21, S("a12345678901234567890"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 1, 0, S("a"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 1, 1, S("a2"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 1, 9, S("a234567890"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 1, 18, S("a234567890123456789"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 1, 19, S("a2345678901234567890"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 1, 20, S("a2345678901234567890"));
+
+    return true;
 }
 
 template <class S>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 10, 0, S("a"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 10, 1, S("a1"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 10, 5, S("a12345"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 10, 9, S("a123456789"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 10, 10, S("a1234567890"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 10, 11, S("a1234567890"));
     test(S("abcdefghij"), 1, 10, S("12345678901234567890"), 19, 0, S("a"));
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghij"), 5, 1, S("12345"), 0, 4, S("abcde1234ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 0, 5, S("abcde12345ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 0, 6, S("abcde12345ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 1, 0, S("abcdeghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 1, 1, S("abcde2ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 1, 2, S("abcde23ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 1, 3, S("abcde234ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 1, 4, S("abcde2345ghij"));
+
+    return true;
 }
 
 template <class S>
-void test29()
+TEST_CONSTEXPR_CXX20 bool test29()
 {
     test(S("abcdefghij"), 5, 1, S("12345"), 1, 5, S("abcde2345ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 2, 0, S("abcdeghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 2, 1, S("abcde3ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 2, 2, S("abcde34ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 2, 3, S("abcde345ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 2, 4, S("abcde345ghij"));
     test(S("abcdefghij"), 5, 1, S("12345"), 4, 0, S("abcdeghij"));
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghij"), 5, 2, S("1234567890"), 1, 0, S("abcdehij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 1, 1, S("abcde2hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 1, 4, S("abcde2345hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 1, 8, S("abcde23456789hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 1, 9, S("abcde234567890hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 1, 10, S("abcde234567890hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 5, 0, S("abcdehij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 5, 1, S("abcde6hij"));
+
+    return true;
 }
 
 template <class S>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test(S("abcdefghij"), 5, 2, S("1234567890"), 5, 2, S("abcde67hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 5, 4, S("abcde6789hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 5, 5, S("abcde67890hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 5, 6, S("abcde67890hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 9, 0, S("abcdehij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 9, 1, S("abcde0hij"));
     test(S("abcdefghij"), 5, 2, S("1234567890"), 9, 2, S("abcde0hij"));
TEST_CONSTEXPR_CXX20 bool test30()
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 1, 9, S("abcde234567890j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 1, 18, S("abcde234567890123456789j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 1, 19, S("abcde2345678901234567890j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 1, 20, S("abcde2345678901234567890j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 10, 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 10, 1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 10, 5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 10, 9, S("abcde123456789j"));
+
+    return true;
 }
 
 template <class S>
-void test31()
+TEST_CONSTEXPR_CXX20 bool test31()
 {
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 10, 10, S("abcde1234567890j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 10, 11, S("abcde1234567890j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 19, 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 19, 1, S("abcde0j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 19, 2, S("abcde0j"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 20, 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, S("12345678901234567890"), 20, 1, S("abcdej"));
TEST_CONSTEXPR_CXX20 bool test31()
     test(S("abcdefghij"), 5, 6, S("12345"), 1, 1, S("abcde2"));
     test(S("abcdefghij"), 5, 6, S("12345"), 1, 2, S("abcde23"));
     test(S("abcdefghij"), 5, 6, S("12345"), 1, 3, S("abcde234"));
     test(S("abcdefghij"), 5, 6, S("12345"), 1, 4, S("abcde2345"));
     test(S("abcdefghij"), 5, 6, S("12345"), 1, 5, S("abcde2345"));
     test(S("abcdefghij"), 5, 6, S("12345"), 2, 0, S("abcde"));
     test(S("abcdefghij"), 5, 6, S("12345"), 2, 1, S("abcde3"));
     test(S("abcdefghij"), 5, 6, S("12345"), 2, 2, S("abcde34"));
+
+    return true;
 }
 
 template <class S>
-void test32()
+TEST_CONSTEXPR_CXX20 bool test32()
 {
     test(S("abcdefghij"), 5, 6, S("12345"), 2, 3, S("abcde345"));
     test(S("abcdefghij"), 5, 6, S("12345"), 2, 4, S("abcde345"));
     test(S("abcdefghij"), 5, 6, S("12345"), 4, 0, S("abcde"));
     test(S("abcdefghij"), 5, 6, S("12345"), 4, 1, S("abcde5"));
     test(S("abcdefghij"), 5, 6, S("12345"), 4, 2, S("abcde5"));
     test(S("abcdefghij"), 5, 6, S("12345"), 5, 0, S("abcde"));
     test(S("abcdefghij"), 5, 6, S("12345"), 5, 1, S("abcde"));
TEST_CONSTEXPR_CXX20 bool test32()
     test(S("abcdefghij"), 9, 0, S("1234567890"), 1, 9, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 1, 10, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 5, 1, S("abcdefghi6j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 5, 2, S("abcdefghi67j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 5, 4, S("abcdefghi6789j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 5, 5, S("abcdefghi67890j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 5, 6, S("abcdefghi67890j"));
+
+    return true;
 }
 
 template <class S>
-void test33()
+TEST_CONSTEXPR_CXX20 bool test33()
 {
     test(S("abcdefghij"), 9, 0, S("1234567890"), 9, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 9, 1, S("abcdefghi0j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 9, 2, S("abcdefghi0j"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 10, 1, S("abcdefghij"));
     test(S("abcdefghij"), 9, 0, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghij"), 9, 0, S("12345678901234567890"), 0, 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test33()
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 10, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 10, 1, S("abcdefghi1"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 10, 5, S("abcdefghi12345"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 10, 9, S("abcdefghi123456789"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 10, 10, S("abcdefghi1234567890"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 10, 11, S("abcdefghi1234567890"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 19, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 19, 1, S("abcdefghi0"));
+
+    return true;
 }
 
 template <class S>
-void test34()
+TEST_CONSTEXPR_CXX20 bool test34()
 {
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 19, 2, S("abcdefghi0"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 20, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 20, 1, S("abcdefghi"));
     test(S("abcdefghij"), 9, 1, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghij"), 9, 2, S(""), 0, 0, S("abcdefghi"));
     test(S("abcdefghij"), 9, 2, S(""), 0, 1, S("abcdefghi"));
     test(S("abcdefghij"), 9, 2, S(""), 1, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test34()
     test(S("abcdefghij"), 10, 0, S("12345"), 1, 5, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, 0, S("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, S("12345"), 2, 1, S("abcdefghij3"));
     test(S("abcdefghij"), 10, 0, S("12345"), 2, 2, S("abcdefghij34"));
     test(S("abcdefghij"), 10, 0, S("12345"), 2, 3, S("abcdefghij345"));
     test(S("abcdefghij"), 10, 0, S("12345"), 2, 4, S("abcdefghij345"));
     test(S("abcdefghij"), 10, 0, S("12345"), 4, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, S("12345"), 4, 1, S("abcdefghij5"));
+
+    return true;
 }
 
 template <class S>
-void test35()
+TEST_CONSTEXPR_CXX20 bool test35()
 {
     test(S("abcdefghij"), 10, 0, S("12345"), 4, 2, S("abcdefghij5"));
     test(S("abcdefghij"), 10, 0, S("12345"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, S("12345"), 5, 1, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, S("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghij"), 10, 0, S("1234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 0, S("1234567890"), 0, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, 0, S("1234567890"), 0, 5, S("abcdefghij12345"));
TEST_CONSTEXPR_CXX20 bool test35()
     test(S("abcdefghij"), 10, 1, S("1234567890"), 5, 2, S("abcdefghij67"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 5, 4, S("abcdefghij6789"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 5, 5, S("abcdefghij67890"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 5, 6, S("abcdefghij67890"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 9, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 9, 1, S("abcdefghij0"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 9, 2, S("abcdefghij0"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 10, 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test36()
+TEST_CONSTEXPR_CXX20 bool test36()
 {
     test(S("abcdefghij"), 10, 1, S("1234567890"), 10, 1, S("abcdefghij"));
     test(S("abcdefghij"), 10, 1, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghij"), 10, 1, S("12345678901234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, 1, S("12345678901234567890"), 0, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, 1, S("12345678901234567890"), 0, 10, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, 1, S("12345678901234567890"), 0, 19, S("abcdefghij1234567890123456789"));
     test(S("abcdefghij"), 10, 1, S("12345678901234567890"), 0, 20, S("abcdefghij12345678901234567890"));
TEST_CONSTEXPR_CXX20 bool test36()
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 10, 10, S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 10, 11, S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 19, 0, S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 19, 1, S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 19, 2, S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 20, 0, S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 20, 1, S("can't happen"));
     test(S("abcdefghij"), 11, 0, S("12345678901234567890"), 21, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test37()
+TEST_CONSTEXPR_CXX20 bool test37()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S("12345"), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S("12345"), 0, 1, S("1abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S("12345"), 0, 2, S("12abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, S("12345"), 0, 4, S("1234abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test37()
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 2, 3, S("345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 2, 4, S("345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 4, 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 4, 1, S("5bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 4, 2, S("5bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 5, 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 5, 1, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("12345"), 6, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test38()
+TEST_CONSTEXPR_CXX20 bool test38()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), 0, 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), 0, 1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), 0, 5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), 0, 9, S("123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), 0, 10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), 0, 11, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, S("1234567890"), 1, 0, S("bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test38()
     test(S("abcdefghijklmnopqrst"), 0, 10, S("1234567890"), 9, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("1234567890"), 9, 1, S("0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("1234567890"), 9, 2, S("0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("1234567890"), 10, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("1234567890"), 10, 1, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 0, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 0, 1, S("1klmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test39()
+TEST_CONSTEXPR_CXX20 bool test39()
 {
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 0, 10, S("1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 0, 19, S("1234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 0, 20, S("12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 0, 21, S("12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 1, 0, S("klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 1, 1, S("2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 10, S("12345678901234567890"), 1, 9, S("234567890klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test39()
     test(S("abcdefghijklmnopqrst"), 0, 19, S("12345678901234567890"), 19, 2, S("0t"));
     test(S("abcdefghijklmnopqrst"), 0, 19, S("12345678901234567890"), 20, 0, S("t"));
     test(S("abcdefghijklmnopqrst"), 0, 19, S("12345678901234567890"), 20, 1, S("t"));
     test(S("abcdefghijklmnopqrst"), 0, 19, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 0, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 0, 1, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 0, 0, S(""));
+
+    return true;
 }
 
 template <class S>
-void test40()
+TEST_CONSTEXPR_CXX20 bool test40()
 {
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 0, 1, S("1"));
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 0, 2, S("12"));
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 0, 4, S("1234"));
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 0, 5, S("12345"));
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 0, 6, S("12345"));
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 1, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 20, S("12345"), 1, 1, S("2"));
TEST_CONSTEXPR_CXX20 bool test40()
     test(S("abcdefghijklmnopqrst"), 0, 21, S("12345"), 4, 2, S("5"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("12345"), 5, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("12345"), 5, 1, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 0, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 0, 1, S("1"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 0, 5, S("12345"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 0, 9, S("123456789"));
+
+    return true;
 }
 
 template <class S>
-void test41()
+TEST_CONSTEXPR_CXX20 bool test41()
 {
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 0, 10, S("1234567890"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 0, 11, S("1234567890"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 1, 0, S(""));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 1, 1, S("2"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 1, 4, S("2345"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 1, 8, S("23456789"));
     test(S("abcdefghijklmnopqrst"), 0, 21, S("1234567890"), 1, 9, S("234567890"));
TEST_CONSTEXPR_CXX20 bool test41()
     test(S("abcdefghijklmnopqrst"), 1, 0, S("1234567890"), 10, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 0, 1, S("a1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 0, 10, S("a1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 0, 19, S("a1234567890123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 0, 20, S("a12345678901234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 0, 21, S("a12345678901234567890bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test42()
+TEST_CONSTEXPR_CXX20 bool test42()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 1, 1, S("a2bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 1, 9, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 1, 18, S("a234567890123456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 1, 19, S("a2345678901234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 1, 20, S("a2345678901234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 0, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test42()
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 0, 0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 0, 1, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 0, 0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 0, 1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 0, 2, S("a12klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 0, 4, S("a1234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 0, 5, S("a12345klmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test43()
+TEST_CONSTEXPR_CXX20 bool test43()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 0, 6, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 1, 0, S("aklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 1, 1, S("a2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 1, 2, S("a23klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 1, 3, S("a234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 1, 4, S("a2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, S("12345"), 1, 5, S("a2345klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test43()
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 0, 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 0, 1, S("a1t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 0, 5, S("a12345t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 0, 9, S("a123456789t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 0, 10, S("a1234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 0, 11, S("a1234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 1, 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 1, 1, S("a2t"));
+
+    return true;
 }
 
 template <class S>
-void test44()
+TEST_CONSTEXPR_CXX20 bool test44()
 {
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 1, 4, S("a2345t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 1, 8, S("a23456789t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 1, 9, S("a234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 1, 10, S("a234567890t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 5, 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 5, 1, S("a6t"));
     test(S("abcdefghijklmnopqrst"), 1, 18, S("1234567890"), 5, 2, S("a67t"));
TEST_CONSTEXPR_CXX20 bool test44()
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 0, 10, S("a1234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 0, 19, S("a1234567890123456789"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 0, 20, S("a12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 0, 21, S("a12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 1, 0, S("a"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 1, 1, S("a2"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 1, 9, S("a234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 1, 18, S("a234567890123456789"));
+
+    return true;
 }
 
 template <class S>
-void test45()
+TEST_CONSTEXPR_CXX20 bool test45()
 {
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 1, 19, S("a2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 1, 20, S("a2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 10, 0, S("a"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 10, 1, S("a1"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 10, 5, S("a12345"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 10, 9, S("a123456789"));
     test(S("abcdefghijklmnopqrst"), 1, 19, S("12345678901234567890"), 10, 10, S("a1234567890"));
TEST_CONSTEXPR_CXX20 bool test45()
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 0, 1, S("abcdefghij1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 0, 2, S("abcdefghij12klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 0, 4, S("abcdefghij1234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 0, 5, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 0, 6, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 1, 1, S("abcdefghij2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 1, 2, S("abcdefghij23klmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test46()
+TEST_CONSTEXPR_CXX20 bool test46()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 1, 3, S("abcdefghij234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 1, 4, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 1, 5, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 2, 1, S("abcdefghij3klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 2, 2, S("abcdefghij34klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 0, S("12345"), 2, 3, S("abcdefghij345klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test46()
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 0, 10, S("abcdefghij1234567890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 0, 11, S("abcdefghij1234567890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 1, 0, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 1, 1, S("abcdefghij2lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 1, 4, S("abcdefghij2345lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 1, 8, S("abcdefghij23456789lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 1, 9, S("abcdefghij234567890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 1, 10, S("abcdefghij234567890lmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test47()
+TEST_CONSTEXPR_CXX20 bool test47()
 {
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 5, 0, S("abcdefghijlmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 5, 1, S("abcdefghij6lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 5, 2, S("abcdefghij67lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 5, 4, S("abcdefghij6789lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 5, 5, S("abcdefghij67890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 5, 6, S("abcdefghij67890lmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 1, S("1234567890"), 9, 0, S("abcdefghijlmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test47()
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 1, 0, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 1, 1, S("abcdefghij2pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 1, 9, S("abcdefghij234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 10, 0, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 10, 1, S("abcdefghij1pqrst"));
+
+    return true;
 }
 
 template <class S>
-void test48()
+TEST_CONSTEXPR_CXX20 bool test48()
 {
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 10, 5, S("abcdefghij12345pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 10, 9, S("abcdefghij123456789pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 10, 10, S("abcdefghij1234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 10, 11, S("abcdefghij1234567890pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 19, 0, S("abcdefghijpqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 19, 1, S("abcdefghij0pqrst"));
     test(S("abcdefghijklmnopqrst"), 10, 5, S("12345678901234567890"), 19, 2, S("abcdefghij0pqrst"));
TEST_CONSTEXPR_CXX20 bool test48()
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 0, 6, S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 1, 2, S("abcdefghij23"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 1, 3, S("abcdefghij234"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 1, 4, S("abcdefghij2345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 1, 5, S("abcdefghij2345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 2, 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test49()
+TEST_CONSTEXPR_CXX20 bool test49()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 2, 1, S("abcdefghij3"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 2, 2, S("abcdefghij34"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 2, 3, S("abcdefghij345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 2, 4, S("abcdefghij345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 4, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 4, 1, S("abcdefghij5"));
     test(S("abcdefghijklmnopqrst"), 10, 10, S("12345"), 4, 2, S("abcdefghij5"));
TEST_CONSTEXPR_CXX20 bool test49()
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 1, 4, S("abcdefghij2345"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 1, 8, S("abcdefghij23456789"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 1, 9, S("abcdefghij234567890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 1, 10, S("abcdefghij234567890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 5, 1, S("abcdefghij6"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 5, 2, S("abcdefghij67"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 5, 4, S("abcdefghij6789"));
+
+    return true;
 }
 
 template <class S>
-void test50()
+TEST_CONSTEXPR_CXX20 bool test50()
 {
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 5, 5, S("abcdefghij67890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 5, 6, S("abcdefghij67890"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 9, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 9, 1, S("abcdefghij0"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 9, 2, S("abcdefghij0"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 11, S("1234567890"), 10, 1, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test50()
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 1, 19, S("abcdefghijklmnopqrs2345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 1, 20, S("abcdefghijklmnopqrs2345678901234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 10, 1, S("abcdefghijklmnopqrs1t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 10, 5, S("abcdefghijklmnopqrs12345t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 10, 9, S("abcdefghijklmnopqrs123456789t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 10, 10, S("abcdefghijklmnopqrs1234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 10, 11, S("abcdefghijklmnopqrs1234567890t"));
+
+    return true;
 }
 
 template <class S>
-void test51()
+TEST_CONSTEXPR_CXX20 bool test51()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 19, 2, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, 0, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 19, 1, S(""), 0, 0, S("abcdefghijklmnopqrs"));
TEST_CONSTEXPR_CXX20 bool test51()
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 1, 3, S("abcdefghijklmnopqrs234"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 1, 4, S("abcdefghijklmnopqrs2345"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 1, 5, S("abcdefghijklmnopqrs2345"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 2, 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 2, 1, S("abcdefghijklmnopqrs3"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 2, 2, S("abcdefghijklmnopqrs34"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 2, 3, S("abcdefghijklmnopqrs345"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 2, 4, S("abcdefghijklmnopqrs345"));
+
+    return true;
 }
 
 template <class S>
-void test52()
+TEST_CONSTEXPR_CXX20 bool test52()
 {
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 4, 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 4, 1, S("abcdefghijklmnopqrs5"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 4, 2, S("abcdefghijklmnopqrs5"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 5, 0, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 5, 1, S("abcdefghijklmnopqrs"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("12345"), 6, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 19, 2, S("1234567890"), 0, 0, S("abcdefghijklmnopqrs"));
TEST_CONSTEXPR_CXX20 bool test52()
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 5, 1, S("abcdefghijklmnopqrst6"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 5, 2, S("abcdefghijklmnopqrst67"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 5, 4, S("abcdefghijklmnopqrst6789"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 5, 5, S("abcdefghijklmnopqrst67890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 5, 6, S("abcdefghijklmnopqrst67890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 9, 1, S("abcdefghijklmnopqrst0"));
+
+    return true;
 }
 
 template <class S>
-void test53()
+TEST_CONSTEXPR_CXX20 bool test53()
 {
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 9, 2, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 10, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("12345678901234567890"), 0, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("12345678901234567890"), 0, 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, 0, S("12345678901234567890"), 0, 10, S("abcdefghijklmnopqrst1234567890"));
TEST_CONSTEXPR_CXX20 bool test53()
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 10, 5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 10, 9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 10, 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 10, 11, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 19, 2, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test54()
+TEST_CONSTEXPR_CXX20 bool test54()
 {
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 1, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345"), 0, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345"), 0, 1, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test54()
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 10, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 10, 11, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 19, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 19, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 19, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 20, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 20, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), 21, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test55()
+TEST_CONSTEXPR_CXX20 bool test55()
 {
     test_npos(S("abcdefghij"), 9, 1, S("12345678901234567890"), 10, S("abcdefghi1234567890"));
     test_npos(S("abcdefghij"), 9, 1, S("12345678901234567890"), 19, S("abcdefghi0"));
     test_npos(S("abcdefghij"), 9, 1, S("12345678901234567890"), 20, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 1, S("12345678901234567890"), 20, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 1, S("12345678901234567890"), 21, S("can't happen"));
     test_npos(S("abcdefghij"), 9, 2, S(""), 0, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 2, S(""), 1, S("can't happen"));
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 0, S("abcdefghi12345"));
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 1, S("abcdefghi2345"));
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 2, S("abcdefghi345"));
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 4, S("abcdefghi5"));
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 5, S("abcdefghi"));
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 6, S("can't happen"));
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    test12<S>();
-    test13<S>();
-    test14<S>();
-    test15<S>();
-    test16<S>();
-    test17<S>();
-    test18<S>();
-    test19<S>();
-    test20<S>();
-    test21<S>();
-    test22<S>();
-    test23<S>();
-    test24<S>();
-    test25<S>();
-    test26<S>();
-    test27<S>();
-    test28<S>();
-    test29<S>();
-    test30<S>();
-    test31<S>();
-    test32<S>();
-    test33<S>();
-    test34<S>();
-    test35<S>();
-    test36<S>();
-    test37<S>();
-    test38<S>();
-    test39<S>();
-    test40<S>();
-    test41<S>();
-    test42<S>();
-    test43<S>();
-    test44<S>();
-    test45<S>();
-    test46<S>();
-    test47<S>();
-    test48<S>();
-    test49<S>();
-    test50<S>();
-    test51<S>();
-    test52<S>();
-    test53<S>();
-    test54<S>();
-    test55<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    test12<S>();
-    test13<S>();
-    test14<S>();
-    test15<S>();
-    test16<S>();
-    test17<S>();
-    test18<S>();
-    test19<S>();
-    test20<S>();
-    test21<S>();
-    test22<S>();
-    test23<S>();
-    test24<S>();
-    test25<S>();
-    test26<S>();
-    test27<S>();
-    test28<S>();
-    test29<S>();
-    test30<S>();
-    test31<S>();
-    test32<S>();
-    test33<S>();
-    test34<S>();
-    test35<S>();
-    test36<S>();
-    test37<S>();
-    test38<S>();
-    test39<S>();
-    test40<S>();
-    test41<S>();
-    test42<S>();
-    test43<S>();
-    test44<S>();
-    test45<S>();
-    test46<S>();
-    test47<S>();
-    test48<S>();
-    test49<S>();
-    test50<S>();
-    test51<S>();
-    test52<S>();
-    test53<S>();
-    test54<S>();
-    test55<S>();
-    }
+template <class S>
+void test() {
+
+#if TEST_STD_VER > 17
+  // static_assert(test0<S>());
+  // static_assert(test1<S>());
+  // static_assert(test2<S>());
+  // static_assert(test3<S>());
+  // static_assert(test4<S>());
+  // static_assert(test5<S>());
+  // static_assert(test6<S>());
+  // static_assert(test7<S>());
+  // static_assert(test8<S>());
+  // static_assert(test9<S>());
+  // static_assert(test10<S>());
+  // static_assert(test11<S>());
+  // static_assert(test12<S>());
+  // static_assert(test13<S>());
+  // static_assert(test14<S>());
+  // static_assert(test15<S>());
+  // static_assert(test16<S>());
+  // static_assert(test17<S>());
+  // static_assert(test18<S>());
+  // static_assert(test19<S>());
+  // static_assert(test20<S>());
+  // static_assert(test21<S>());
+  // static_assert(test22<S>());
+  // static_assert(test23<S>());
+  // static_assert(test24<S>());
+  // static_assert(test25<S>());
+  // static_assert(test26<S>());
+  // static_assert(test27<S>());
+  // static_assert(test28<S>());
+  // static_assert(test29<S>());
+  // static_assert(test30<S>());
+  // static_assert(test31<S>());
+  // static_assert(test32<S>());
+  // static_assert(test33<S>());
+  // static_assert(test34<S>());
+  // static_assert(test35<S>());
+  // static_assert(test36<S>());
+  // static_assert(test37<S>());
+  // static_assert(test38<S>());
+  // static_assert(test39<S>());
+  // static_assert(test40<S>());
+  // static_assert(test41<S>());
+  // static_assert(test42<S>());
+  // static_assert(test43<S>());
+  // static_assert(test44<S>());
+  // static_assert(test45<S>());
+  // static_assert(test46<S>());
+  // static_assert(test47<S>());
+  // static_assert(test48<S>());
+  // static_assert(test49<S>());
+  // static_assert(test50<S>());
+  // static_assert(test51<S>());
+  // static_assert(test52<S>());
+  // static_assert(test53<S>());
+  // static_assert(test54<S>());
+  // static_assert(test55<S>());
+#endif
+
+int main(int, char**)
+  test<std::string>();
+#if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp

 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
     {
         s.replace(pos1, n1, sv);
         LIBCPP_ASSERT(s.__invariants());
else
             assert(pos1 > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, SV(""), S(""));
     test(S(""), 0, 0, SV("12345"), S("12345"));
     test(S(""), 0, 0, SV("1234567890"), S("1234567890"));
     test(S(""), 0, 0, SV("12345678901234567890"), S("12345678901234567890"));
     test(S(""), 0, 1, SV(""), S(""));
     test(S(""), 0, 1, SV("12345"), S("12345"));
     test(S(""), 0, 1, SV("1234567890"), S("1234567890"));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890"));
     test(S("abcde"), 5, 1, SV(""), S("abcde"));
     test(S("abcde"), 5, 1, SV("12345"), S("abcde12345"));
     test(S("abcde"), 5, 1, SV("1234567890"), S("abcde1234567890"));
     test(S("abcde"), 5, 1, SV("12345678901234567890"), S("abcde12345678901234567890"));
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, SV(""), S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345"), S("can't happen"));
     test(S("abcde"), 6, 0, SV("1234567890"), S("can't happen"));
     test(S("abcde"), 6, 0, SV("12345678901234567890"), S("can't happen"));
     test(S("abcdefghij"), 0, 0, SV(""), S("abcdefghij"));
     test(S("abcdefghij"), 0, 0, SV("12345"), S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, SV("1234567890"), S("1234567890abcdefghij"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 11, 0, SV(""), S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345"), S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("1234567890"), S("can't happen"));
     test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), S("can't happen"));
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV(""), S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), S("1234567890bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("1234567890"), S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), S("can't happen"));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     typedef std::string_view SV;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
-    }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_swap/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;
     s1.swap(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;
 }