[libc++][NFC] Remove some of the code duplication in the string tests

[philnik]

• Fix test

[huixie90]

LGTM

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

59

In one place, I saw you changed from > 3 to >= 11. To be consistent, either change this one too or revert the other change.
I suppose this is checking the version is > Cxx03. I thought we need to use a different macro to check if the version is CXX03 in the non-test code and didn't know that this is working.

[ldionne]

LGTM w/ comments.

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

59

This is so weird, we should use TEST_STD_VER >= 11 everywhere. I didn't know we had TEST_STD_VER > 3 anywhere in the code base.

[philnik]

• replace > 3 with >= 11 in the string tests

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

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::out_of_range&)
         {
             assert(pos >= s.size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), 0);
-    test(S("123"), 0);
-    test(S("123"), 1);
-    test(S("123"), 2);
-    test(S("123"), 3);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), 0);
-    test(S("123"), 0);
-    test(S("123"), 1);
-    test(S("123"), 2);
-    test(S("123"), 3);
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.access/back.pass.cpp

test(S s)
     LIBCPP_ASSERT_NOEXCEPT(    s.back());
     LIBCPP_ASSERT_NOEXCEPT(   cs.back());
     assert(&cs.back() == &cs[cs.size()-1]);
     assert(&s.back() == &s[cs.size()-1]);
     s.back() = typename S::value_type('z');
     assert(s.back() == typename S::value_type('z'));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S("1"));
-    test(S("1234567890123456789012345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S("1"));
-    test(S("1234567890123456789012345678901234567890"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.access/front.pass.cpp

test(S s)
     LIBCPP_ASSERT_NOEXCEPT(    s.front());
     LIBCPP_ASSERT_NOEXCEPT(   cs.front());
     assert(&cs.front() == &cs[0]);
     assert(&s.front() == &s[0]);
     s.front() = typename S::value_type('z');
     assert(s.front() == typename S::value_type('z'));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S("1"));
-    test(S("1234567890123456789012345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S("1"));
-    test(S("1234567890123456789012345678901234567890"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.access/index.pass.cpp

 //       reference operator[](size_type pos); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    S s("0123456789");
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s[0]), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs[0]), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s[0]);
-    LIBCPP_ASSERT_NOEXCEPT(   cs[0]);
-    for (S::size_type i = 0; i < cs.size(); ++i)
-    {
-        assert(s[i] == static_cast<char>('0' + i));
-        assert(cs[i] == s[i]);
-    }
-    assert(cs[cs.size()] == '\0');
-    const S s2 = S();
-    assert(s2[0] == '\0');
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  for (typename S::size_type i = 0; i < cs.size(); ++i)
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s("0123456789");
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s[0]), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs[0]), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s[0]);
-    LIBCPP_ASSERT_NOEXCEPT(   cs[0]);
-    for (S::size_type i = 0; i < cs.size(); ++i)
-    {
-        assert(s[i] == static_cast<char>('0' + i));
-        assert(cs[i] == s[i]);
-    }
-    assert(cs[cs.size()] == '\0');
-    const S s2 = S();
-    assert(s2[0] == '\0');
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/clear.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     s.clear();
     assert(s.size() == 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    S s;
-    test(s);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    s.assign(10, 'a');
-    s.erase(5);
-    test(s);
 
-    s.assign(100, 'a');
-    s.erase(50);
-    test(s);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s;
-    test(s);
 
-    s.assign(10, 'a');
-    s.erase(5);
-    test(s);
-
-    s.assign(100, 'a');
-    s.erase(50);
-    test(s);
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/empty.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     ASSERT_NOEXCEPT(s.empty());
     assert(s.empty() == (s.size() == 0));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-    test(S("12345678901234567890123456789012345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-    test(S("12345678901234567890123456789012345678901234567890"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/length.pass.cpp

 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     assert(s.length() == s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-    test(S("12345678901234567890123456789012345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-    test(S("12345678901234567890123456789012345678901234567890"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/max_size.pass.cpp

 TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     assert(s.max_size() >= s.size());
     test1(s);
     test2(s);
 }
 
-void test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-    test(S("12345678901234567890123456789012345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-    test(S("12345678901234567890123456789012345678901234567890"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
+
+  return true;
 }
 
 #if TEST_STD_VER > 17
 constexpr bool test_constexpr() {
   std::string str;
 
   size_t size = str.max_size();
   assert(size > 0);

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

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

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

test(typename S::size_type min_cap, typename S::size_type erased_index)
     S s0 = s;
     s.reserve();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
 }
 
-bool test() {
-    {
-    typedef std::string S;
-    {
-    test<S>(0, 0);
-    test<S>(10, 5);
-    test<S>(100, 50);
-    }
-    }
+template <class S>
+void test_string() {
+
+bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    {
-    test<S>(0, 0);
-    test<S>(10, 5);
-    test<S>(100, 50);
-    }
-    }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 
   return 0;
 }

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

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::length_error&)
         {
             assert(res_arg > s.max_size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    {
-      test<S>(0, 0, 5);
-      test<S>(0, 0, 10);
-      test<S>(0, 0, 50);
-    }
-    {
-      test<S>(100, 50, 5);
-      test<S>(100, 50, 10);
-      test<S>(100, 50, 50);
-      test<S>(100, 50, 100);
-      test<S>(100, 50, 1000);
-      test<S>(100, 50, S::npos);
-    }
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    {
-      test<S>(0, 0, 5);
-      test<S>(0, 0, 10);
-      test<S>(0, 0, 50);
-    }
-    {
-      test<S>(100, 50, 5);
-      test<S>(100, 50, 10);
-      test<S>(100, 50, 50);
-      test<S>(100, 50, 100);
-      test<S>(100, 50, 1000);
-      test<S>(100, 50, S::npos);
-    }
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/resize_size.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::length_error&)
         {
             assert(n > s.max_size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), 0, S());
-    test(S(), 1, S(1, '\0'));
-    test(S(), 10, S(10, '\0'));
-    test(S(), 100, S(100, '\0'));
-    test(S("12345"), 0, S());
-    test(S("12345"), 2, S("12"));
-    test(S("12345"), 5, S("12345"));
-    test(S("12345"), 15, S("12345\0\0\0\0\0\0\0\0\0\0", 15));
-    test(S("12345678901234567890123456789012345678901234567890"), 0, S());
-    test(S("12345678901234567890123456789012345678901234567890"), 10,
-         S("1234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 50,
-         S("12345678901234567890123456789012345678901234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 60,
-         S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
-    test(S(), S::npos, S("not going to happen"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), 0, S());
-    test(S(), 1, S(1, '\0'));
-    test(S(), 10, S(10, '\0'));
-    test(S(), 100, S(100, '\0'));
-    test(S("12345"), 0, S());
-    test(S("12345"), 2, S("12"));
-    test(S("12345"), 5, S("12345"));
-    test(S("12345"), 15, S("12345\0\0\0\0\0\0\0\0\0\0", 15));
-    test(S("12345678901234567890123456789012345678901234567890"), 0, S());
-    test(S("12345678901234567890123456789012345678901234567890"), 10,
-         S("1234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 50,
-         S("12345678901234567890123456789012345678901234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 60,
-         S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
-    test(S(), S::npos, S("not going to happen"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/resize_size_char.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::length_error&)
         {
             assert(n > s.max_size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), 0, 'a', S());
-    test(S(), 1, 'a', S("a"));
-    test(S(), 10, 'a', S(10, 'a'));
-    test(S(), 100, 'a', S(100, 'a'));
-    test(S("12345"), 0, 'a', S());
-    test(S("12345"), 2, 'a', S("12"));
-    test(S("12345"), 5, 'a', S("12345"));
-    test(S("12345"), 15, 'a', S("12345aaaaaaaaaa"));
-    test(S("12345678901234567890123456789012345678901234567890"), 0, 'a', S());
-    test(S("12345678901234567890123456789012345678901234567890"), 10, 'a',
-         S("1234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 50, 'a',
-         S("12345678901234567890123456789012345678901234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
-         S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
-    test(S(), S::npos, 'a', S("not going to happen"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), 0, 'a', S());
-    test(S(), 1, 'a', S("a"));
-    test(S(), 10, 'a', S(10, 'a'));
-    test(S(), 100, 'a', S(100, 'a'));
-    test(S("12345"), 0, 'a', S());
-    test(S("12345"), 2, 'a', S("12"));
-    test(S("12345"), 5, 'a', S("12345"));
-    test(S("12345"), 15, 'a', S("12345aaaaaaaaaa"));
-    test(S("12345678901234567890123456789012345678901234567890"), 0, 'a', S());
-    test(S("12345678901234567890123456789012345678901234567890"), 10, 'a',
-         S("1234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 50, 'a',
-         S("12345678901234567890123456789012345678901234567890"));
-    test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
-         S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
-    test(S(), S::npos, 'a', S("not going to happen"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/shrink_to_fit.pass.cpp

test(S s)
     S s0 = s;
     s.shrink_to_fit();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    S s;
-    test(s);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    s.assign(10, 'a');
-    s.erase(5);
-    test(s);
 
-    s.assign(100, 'a');
-    s.erase(50);
-    test(s);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s;
-    test(s);
 
-    s.assign(10, 'a');
-    s.erase(5);
-    test(s);
-
-    s.assign(100, 'a');
-    s.erase(50);
-    test(s);
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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.capacity/size.pass.cpp

 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type c)
 {
     assert(s.size() == c);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), 0);
-    test(S("123"), 3);
-    test(S("12345678901234567890123456789012345678901234567890"), 50);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), 0);
-    test(S("123"), 3);
-    test(S("12345678901234567890123456789012345678901234567890"), 50);
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.cons/char_assignment.pass.cpp

test(S s1, typename S::value_type s2)
     typedef typename S::traits_type T;
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == 1);
     assert(T::eq(s1[0], s2));
     assert(s1.capacity() >= s1.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), 'a');
-    test(S("1"), 'a');
-    test(S("123456789"), 'a');
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), 'a');
-    test(S("1"), 'a');
-    test(S("123456789"), 'a');
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.cons/copy_assignment.pass.cpp

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

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

test(S s1, S s2)
     S s0 = s2;
     s1 = std::move(s2);
     LIBCPP_ASSERT(s1.__invariants());
     LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s0);
     assert(s1.capacity() >= s1.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), S());
-    test(S("1"), S());
-    test(S(), S("1"));
-    test(S("1"), S("2"));
-    test(S("1"), S("2"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("123456789"),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-           "1234567890123456789012345678901234567890123456789012345678901234567890"),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), S());
-    test(S("1"), S());
-    test(S(), S("1"));
-    test(S("1"), S("2"));
-    test(S("1"), S("2"));
 
-    test(S(),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("123456789"),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-           "1234567890123456789012345678901234567890123456789012345678901234567890"),
-         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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.cons/pointer_assignment.pass.cpp

test(S s1, const typename S::value_type* s2)
     typedef typename S::traits_type T;
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == T::length(s2));
     assert(T::compare(s1.data(), s2, s1.size()) == 0);
     assert(s1.capacity() >= s1.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), "");
-    test(S("1"), "");
-    test(S(), "1");
-    test(S("1"), "2");
-    test(S("1"), "2");
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    test(S("123456789"),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-           "1234567890123456789012345678901234567890123456789012345678901234567890"),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), "");
-    test(S("1"), "");
-    test(S(), "1");
-    test(S("1"), "2");
-    test(S("1"), "2");
 
-    test(S(),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    test(S("123456789"),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-           "1234567890123456789012345678901234567890123456789012345678901234567890"),
-         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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.cons/string_view_assignment.pass.cpp

test(S s1, SV sv)
     typedef typename S::traits_type T;
     s1 = sv;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == sv.size());
     assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
     assert(s1.capacity() >= s1.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(S(), SV(""));
-    test(S("1"), SV(""));
-    test(S(), SV("1"));
-    test(S("1"), SV("2"));
-    test(S("1"), SV("2"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("123456789"),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-           "1234567890123456789012345678901234567890123456789012345678901234567890"),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test(S(), SV(""));
-    test(S("1"), SV(""));
-    test(S(), SV("1"));
-    test(S("1"), SV("2"));
-    test(S("1"), SV("2"));
 
-    test(S(),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("123456789"),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-           "1234567890123456789012345678901234567890123456789012345678901234567890"),
-         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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_append/T_size_size.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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"));
#endif
     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/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
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S("12345"), s, s, S("12345"));
-    test(S("12345"), s, s+1, S("12345A"));
-    test(S("12345"), s, s+10, S("12345ABCDEFGHIJ"));
-    test(S("12345"), s, s+52, S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), s, s, S("1234567890"));
-    test(S("1234567890"), s, s+1, S("1234567890A"));
-    test(S("1234567890"), s, s+10, S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345678901234567890"), s, s, S("12345678901234567890"));
-    test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A"));
-    test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ"));
-    test(S("12345678901234567890"), s, s+52,
-         S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S("12345"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("12345A"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("12345ABCDEFGHIJ"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S("1234567890"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("1234567890A"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    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"));
-    test(S("12345"), s, s+1, S("12345A"));
-    test(S("12345"), s, s+10, S("12345ABCDEFGHIJ"));
-    test(S("12345"), s, s+52, S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), s, s, S("1234567890"));
-    test(S("1234567890"), s, s+1, S("1234567890A"));
-    test(S("1234567890"), s, s+10, S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("12345678901234567890"), s, s, S("12345678901234567890"));
-    test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A"));
-    test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ"));
-    test(S("12345678901234567890"), s, s+52,
-         S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S("12345"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("12345A"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("12345ABCDEFGHIJ"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S("1234567890"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("1234567890A"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // 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()));

libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp

 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.append(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), "", S());
-    test(S(), "12345", S("12345"));
-    test(S(), "12345678901234567890", S("12345678901234567890"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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

 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);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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());

libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp

 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);
 }
 
-TEST_CONSTEXPR_CXX20 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'));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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_append/string.pass.cpp

 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.append(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
 #if TEST_STD_VER > 3
   {   // LWG 2946
     std::string s;
     s.append({"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");
   }
 #endif
 

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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(""));

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

 TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, S expected)
 {
     s.append(sv);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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_assign/T_size_size.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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"));
#endif
     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/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
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S("12345"), s, s, S());
-    test(S("12345"), s, s+1, S("A"));
-    test(S("12345"), s, s+10, S("ABCDEFGHIJ"));
-    test(S("12345"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), s, s, S());
-    test(S("1234567890"), s, s+1, S("A"));
-    test(S("1234567890"), s, s+10, S("ABCDEFGHIJ"));
-    test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345678901234567890"), s, s, S());
-    test(S("12345678901234567890"), s, s+1, S("A"));
-    test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ"));
-    test(S("12345678901234567890"), s, s+52,
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S());
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("A"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S());
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("A"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    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());
-    test(S("12345"), s, s+1, S("A"));
-    test(S("12345"), s, s+10, S("ABCDEFGHIJ"));
-    test(S("12345"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), s, s, S());
-    test(S("1234567890"), s, s+1, S("A"));
-    test(S("1234567890"), s, s+10, S("ABCDEFGHIJ"));
-    test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("12345678901234567890"), s, s, S());
-    test(S("12345678901234567890"), s, s+1, S("A"));
-    test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ"));
-    test(S("12345678901234567890"), s, s+52,
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S());
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("A"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
-         S());
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
-         S("A"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
-         S("ABCDEFGHIJ"));
-    test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
-         S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // 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()));
#endif
   }
 
   { // 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

 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);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), "", S());
-    test(S(), "12345", S("12345"));
-    test(S(), "12345678901234567890", S("12345678901234567890"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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());

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp

 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);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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

 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.assign(std::move(str));
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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_assign/size_char.pass.cpp

 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);
 }
 
-TEST_CONSTEXPR_CXX20 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'));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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'));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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_assign/string_size_size.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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(""));

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

 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);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S("12345"), SV(), S());
-    test(S("12345"), SV("12345"), S("12345"));
-    test(S("12345"), SV("1234567890"), S("1234567890"));
-    test(S("12345"), SV("12345678901234567890"), S("12345678901234567890"));
 
-    test(S("1234567890"), SV(), S());
-    test(S("1234567890"), SV("12345"), S("12345"));
-    test(S("1234567890"), SV("1234567890"), S("1234567890"));
-    test(S("1234567890"), SV("12345678901234567890"), S("12345678901234567890"));
 
-    test(S("12345678901234567890"), SV(), S());
-    test(S("12345678901234567890"), SV("12345"), S("12345"));
-    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>());
-  }
+  using A = typename S::allocator_type;
+
+  testAlloc(S(), SV(), A());
+  testAlloc(S(), SV("12345"), A());
+  testAlloc(S(), SV("1234567890"), A());
+  testAlloc(S(), SV("12345678901234567890"), A());
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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());
-    test(S("12345"), SV("12345"), S("12345"));
-    test(S("12345"), SV("1234567890"), S("1234567890"));
-    test(S("12345"), SV("12345678901234567890"), S("12345678901234567890"));
-
-    test(S("1234567890"), SV(), S());
-    test(S("1234567890"), SV("12345"), S("12345"));
-    test(S("1234567890"), SV("1234567890"), S("1234567890"));
-    test(S("1234567890"), SV("12345678901234567890"), S("12345678901234567890"));
-
-    test(S("12345678901234567890"), SV(), S());
-    test(S("12345678901234567890"), SV("12345"), S("12345"));
-    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>());
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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 if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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);
-    test(S("abcde"), s, 0, 4);
-    test(S("abcde"), s, 0, 5);
-    test(S("abcde"), s, 0, 6);
-    test(S("abcde"), s, 1, 0);
-    test(S("abcde"), s, 1, 1);
-    test(S("abcde"), s, 1, 2);
-    test(S("abcde"), s, 1, 4);
-    test(S("abcde"), s, 1, 5);
-    test(S("abcde"), s, 2, 0);
-    test(S("abcde"), s, 2, 1);
-    test(S("abcde"), s, 2, 2);
-    test(S("abcde"), s, 2, 4);
-    test(S("abcde"), s, 4, 0);
-    test(S("abcde"), s, 4, 1);
-    test(S("abcde"), s, 4, 2);
-    test(S("abcde"), s, 5, 0);
-    test(S("abcde"), s, 5, 1);
-    test(S("abcde"), s, 6, 0);
-    test(S("abcdefghijklmnopqrst"), s, 0, 0);
-    test(S("abcdefghijklmnopqrst"), s, 0, 1);
-    test(S("abcdefghijklmnopqrst"), s, 0, 2);
-    test(S("abcdefghijklmnopqrst"), s, 0, 10);
-    test(S("abcdefghijklmnopqrst"), s, 0, 19);
-    test(S("abcdefghijklmnopqrst"), s, 0, 20);
-    test(S("abcdefghijklmnopqrst"), s, 0, 21);
-    test(S("abcdefghijklmnopqrst"), s, 1, 0);
-    test(S("abcdefghijklmnopqrst"), s, 1, 1);
-    test(S("abcdefghijklmnopqrst"), s, 1, 2);
-    test(S("abcdefghijklmnopqrst"), s, 1, 9);
-    test(S("abcdefghijklmnopqrst"), s, 1, 18);
-    test(S("abcdefghijklmnopqrst"), s, 1, 19);
-    test(S("abcdefghijklmnopqrst"), s, 1, 20);
-    test(S("abcdefghijklmnopqrst"), s, 2, 0);
-    test(S("abcdefghijklmnopqrst"), s, 2, 1);
-    test(S("abcdefghijklmnopqrst"), s, 2, 2);
-    test(S("abcdefghijklmnopqrst"), s, 2, 9);
-    test(S("abcdefghijklmnopqrst"), s, 2, 17);
-    test(S("abcdefghijklmnopqrst"), s, 2, 18);
-    test(S("abcdefghijklmnopqrst"), s, 2, 19);
-    test(S("abcdefghijklmnopqrst"), s, 10, 0);
-    test(S("abcdefghijklmnopqrst"), s, 10, 1);
-    test(S("abcdefghijklmnopqrst"), s, 10, 2);
-    test(S("abcdefghijklmnopqrst"), s, 10, 5);
-    test(S("abcdefghijklmnopqrst"), s, 10, 9);
-    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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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);
-    test(S("abcde"), s, 0, 4);
-    test(S("abcde"), s, 0, 5);
-    test(S("abcde"), s, 0, 6);
-    test(S("abcde"), s, 1, 0);
-    test(S("abcde"), s, 1, 1);
-    test(S("abcde"), s, 1, 2);
-    test(S("abcde"), s, 1, 4);
-    test(S("abcde"), s, 1, 5);
-    test(S("abcde"), s, 2, 0);
-    test(S("abcde"), s, 2, 1);
-    test(S("abcde"), s, 2, 2);
-    test(S("abcde"), s, 2, 4);
-    test(S("abcde"), s, 4, 0);
-    test(S("abcde"), s, 4, 1);
-    test(S("abcde"), s, 4, 2);
-    test(S("abcde"), s, 5, 0);
-    test(S("abcde"), s, 5, 1);
-    test(S("abcde"), s, 6, 0);
-    test(S("abcdefghijklmnopqrst"), s, 0, 0);
-    test(S("abcdefghijklmnopqrst"), s, 0, 1);
-    test(S("abcdefghijklmnopqrst"), s, 0, 2);
-    test(S("abcdefghijklmnopqrst"), s, 0, 10);
-    test(S("abcdefghijklmnopqrst"), s, 0, 19);
-    test(S("abcdefghijklmnopqrst"), s, 0, 20);
-    test(S("abcdefghijklmnopqrst"), s, 0, 21);
-    test(S("abcdefghijklmnopqrst"), s, 1, 0);
-    test(S("abcdefghijklmnopqrst"), s, 1, 1);
-    test(S("abcdefghijklmnopqrst"), s, 1, 2);
-    test(S("abcdefghijklmnopqrst"), s, 1, 9);
-    test(S("abcdefghijklmnopqrst"), s, 1, 18);
-    test(S("abcdefghijklmnopqrst"), s, 1, 19);
-    test(S("abcdefghijklmnopqrst"), s, 1, 20);
-    test(S("abcdefghijklmnopqrst"), s, 2, 0);
-    test(S("abcdefghijklmnopqrst"), s, 2, 1);
-    test(S("abcdefghijklmnopqrst"), s, 2, 2);
-    test(S("abcdefghijklmnopqrst"), s, 2, 9);
-    test(S("abcdefghijklmnopqrst"), s, 2, 17);
-    test(S("abcdefghijklmnopqrst"), s, 2, 18);
-    test(S("abcdefghijklmnopqrst"), s, 2, 19);
-    test(S("abcdefghijklmnopqrst"), s, 10, 0);
-    test(S("abcdefghijklmnopqrst"), s, 10, 1);
-    test(S("abcdefghijklmnopqrst"), s, 10, 2);
-    test(S("abcdefghijklmnopqrst"), s, 10, 5);
-    test(S("abcdefghijklmnopqrst"), s, 10, 9);
-    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);
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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_erase/iter.pass.cpp

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);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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_erase/iter_iter.pass.cpp

test(S s, typename S::difference_type pos, typename S::difference_type n, S expected)
     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);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-    test(S("abcde"), 1, 1, S("acde"));
-    test(S("abcde"), 1, 2, S("ade"));
-    test(S("abcde"), 1, 3, S("ae"));
-    test(S("abcde"), 1, 4, S("a"));
-    test(S("abcde"), 2, 0, S("abcde"));
-    test(S("abcde"), 2, 1, S("abde"));
-    test(S("abcde"), 2, 2, S("abe"));
-    test(S("abcde"), 2, 3, S("ab"));
-    test(S("abcde"), 4, 0, S("abcde"));
-    test(S("abcde"), 4, 1, S("abcd"));
-    test(S("abcde"), 5, 0, S("abcde"));
-    test(S("abcdefghij"), 0, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 0, 1, S("bcdefghij"));
-    test(S("abcdefghij"), 0, 5, S("fghij"));
-    test(S("abcdefghij"), 0, 9, S("j"));
-    test(S("abcdefghij"), 0, 10, S(""));
-    test(S("abcdefghij"), 1, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 1, 1, S("acdefghij"));
-    test(S("abcdefghij"), 1, 4, S("afghij"));
-    test(S("abcdefghij"), 1, 8, S("aj"));
-    test(S("abcdefghij"), 1, 9, S("a"));
-    test(S("abcdefghij"), 5, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 5, 1, S("abcdeghij"));
-    test(S("abcdefghij"), 5, 2, S("abcdehij"));
-    test(S("abcdefghij"), 5, 4, S("abcdej"));
-    test(S("abcdefghij"), 5, 5, S("abcde"));
-    test(S("abcdefghij"), 9, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 9, 1, S("abcdefghi"));
-    test(S("abcdefghij"), 10, 0, S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 1, S("bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, S("klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 19, S("t"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, S(""));
-    test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 1, S("acdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 9, S("aklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 18, S("at"));
-    test(S("abcdefghijklmnopqrst"), 1, 19, S("a"));
-    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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-    test(S("abcde"), 1, 1, S("acde"));
-    test(S("abcde"), 1, 2, S("ade"));
-    test(S("abcde"), 1, 3, S("ae"));
-    test(S("abcde"), 1, 4, S("a"));
-    test(S("abcde"), 2, 0, S("abcde"));
-    test(S("abcde"), 2, 1, S("abde"));
-    test(S("abcde"), 2, 2, S("abe"));
-    test(S("abcde"), 2, 3, S("ab"));
-    test(S("abcde"), 4, 0, S("abcde"));
-    test(S("abcde"), 4, 1, S("abcd"));
-    test(S("abcde"), 5, 0, S("abcde"));
-    test(S("abcdefghij"), 0, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 0, 1, S("bcdefghij"));
-    test(S("abcdefghij"), 0, 5, S("fghij"));
-    test(S("abcdefghij"), 0, 9, S("j"));
-    test(S("abcdefghij"), 0, 10, S(""));
-    test(S("abcdefghij"), 1, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 1, 1, S("acdefghij"));
-    test(S("abcdefghij"), 1, 4, S("afghij"));
-    test(S("abcdefghij"), 1, 8, S("aj"));
-    test(S("abcdefghij"), 1, 9, S("a"));
-    test(S("abcdefghij"), 5, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 5, 1, S("abcdeghij"));
-    test(S("abcdefghij"), 5, 2, S("abcdehij"));
-    test(S("abcdefghij"), 5, 4, S("abcdej"));
-    test(S("abcdefghij"), 5, 5, S("abcde"));
-    test(S("abcdefghij"), 9, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 9, 1, S("abcdefghi"));
-    test(S("abcdefghij"), 10, 0, S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 1, S("bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, S("klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 19, S("t"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, S(""));
-    test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 1, S("acdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 9, S("aklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 18, S("at"));
-    test(S("abcdefghijklmnopqrst"), 1, 19, S("a"));
-    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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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_erase/pop_back.pass.cpp

 test(S s, S expected)
 {
     s.pop_back();
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S("abcde"), S("abcd"));
-    test(S("abcdefghij"), S("abcdefghi"));
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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_erase/size_size.pass.cpp

 test(S s, S expected)
 {
     s.erase();
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-    test(S("abcde"), 0, 5, S(""));
-    test(S("abcde"), 0, 6, S(""));
-    test(S("abcde"), 1, 0, S("abcde"));
-    test(S("abcde"), 1, 1, S("acde"));
-    test(S("abcde"), 1, 2, S("ade"));
-    test(S("abcde"), 1, 3, S("ae"));
-    test(S("abcde"), 1, 4, S("a"));
-    test(S("abcde"), 1, 5, S("a"));
-    test(S("abcde"), 2, 0, S("abcde"));
-    test(S("abcde"), 2, 1, S("abde"));
-    test(S("abcde"), 2, 2, S("abe"));
-    test(S("abcde"), 2, 3, S("ab"));
-    test(S("abcde"), 2, 4, S("ab"));
-    test(S("abcde"), 4, 0, S("abcde"));
-    test(S("abcde"), 4, 1, S("abcd"));
-    test(S("abcde"), 4, 2, S("abcd"));
-    test(S("abcde"), 5, 0, S("abcde"));
-    test(S("abcde"), 5, 1, S("abcde"));
-    test(S("abcde"), 6, 0, S("can't happen"));
-    test(S("abcdefghij"), 0, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 0, 1, S("bcdefghij"));
-    test(S("abcdefghij"), 0, 5, S("fghij"));
-    test(S("abcdefghij"), 0, 9, S("j"));
-    test(S("abcdefghij"), 0, 10, S(""));
-    test(S("abcdefghij"), 0, 11, S(""));
-    test(S("abcdefghij"), 1, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 1, 1, S("acdefghij"));
-    test(S("abcdefghij"), 1, 4, S("afghij"));
-    test(S("abcdefghij"), 1, 8, S("aj"));
-    test(S("abcdefghij"), 1, 9, S("a"));
-    test(S("abcdefghij"), 1, 10, S("a"));
-    test(S("abcdefghij"), 5, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 5, 1, S("abcdeghij"));
-    test(S("abcdefghij"), 5, 2, S("abcdehij"));
-    test(S("abcdefghij"), 5, 4, S("abcdej"));
-    test(S("abcdefghij"), 5, 5, S("abcde"));
-    test(S("abcdefghij"), 5, 6, S("abcde"));
-    test(S("abcdefghij"), 9, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 9, 1, S("abcdefghi"));
-    test(S("abcdefghij"), 9, 2, S("abcdefghi"));
-    test(S("abcdefghij"), 10, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 10, 1, S("abcdefghij"));
-    test(S("abcdefghij"), 11, 0, S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 1, S("bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, S("klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 19, S("t"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, S(""));
-    test(S("abcdefghijklmnopqrst"), 0, 21, S(""));
-    test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 1, S("acdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 9, S("aklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 18, S("at"));
-    test(S("abcdefghijklmnopqrst"), 1, 19, S("a"));
-    test(S("abcdefghijklmnopqrst"), 1, 20, S("a"));
-    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"), 10, 11, S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
-    test(S("abcdefghijklmnopqrst"), 19, 2, S("abcdefghijklmnopqrs"));
-    test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 21, 0, S("can't happen"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(""), 0, S(""));
-    test(S(""), 1, S("can't happen"));
-    test(S("abcde"), 0, S(""));
-    test(S("abcde"), 1, S("a"));
-    test(S("abcde"), 2, S("ab"));
-    test(S("abcde"), 4, S("abcd"));
-    test(S("abcde"), 5, S("abcde"));
-    test(S("abcde"), 6, S("can't happen"));
-    test(S("abcdefghij"), 0, S(""));
-    test(S("abcdefghij"), 1, S("a"));
-    test(S("abcdefghij"), 5, S("abcde"));
-    test(S("abcdefghij"), 9, S("abcdefghi"));
-    test(S("abcdefghij"), 10, S("abcdefghij"));
-    test(S("abcdefghij"), 11, S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, S(""));
-    test(S("abcdefghijklmnopqrst"), 1, S("a"));
-    test(S("abcdefghijklmnopqrst"), 10, S("abcdefghij"));
-    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"));
-    test(S("abcde"), 0, 5, S(""));
-    test(S("abcde"), 0, 6, S(""));
-    test(S("abcde"), 1, 0, S("abcde"));
-    test(S("abcde"), 1, 1, S("acde"));
-    test(S("abcde"), 1, 2, S("ade"));
-    test(S("abcde"), 1, 3, S("ae"));
-    test(S("abcde"), 1, 4, S("a"));
-    test(S("abcde"), 1, 5, S("a"));
-    test(S("abcde"), 2, 0, S("abcde"));
-    test(S("abcde"), 2, 1, S("abde"));
-    test(S("abcde"), 2, 2, S("abe"));
-    test(S("abcde"), 2, 3, S("ab"));
-    test(S("abcde"), 2, 4, S("ab"));
-    test(S("abcde"), 4, 0, S("abcde"));
-    test(S("abcde"), 4, 1, S("abcd"));
-    test(S("abcde"), 4, 2, S("abcd"));
-    test(S("abcde"), 5, 0, S("abcde"));
-    test(S("abcde"), 5, 1, S("abcde"));
-    test(S("abcde"), 6, 0, S("can't happen"));
-    test(S("abcdefghij"), 0, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 0, 1, S("bcdefghij"));
-    test(S("abcdefghij"), 0, 5, S("fghij"));
-    test(S("abcdefghij"), 0, 9, S("j"));
-    test(S("abcdefghij"), 0, 10, S(""));
-    test(S("abcdefghij"), 0, 11, S(""));
-    test(S("abcdefghij"), 1, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 1, 1, S("acdefghij"));
-    test(S("abcdefghij"), 1, 4, S("afghij"));
-    test(S("abcdefghij"), 1, 8, S("aj"));
-    test(S("abcdefghij"), 1, 9, S("a"));
-    test(S("abcdefghij"), 1, 10, S("a"));
-    test(S("abcdefghij"), 5, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 5, 1, S("abcdeghij"));
-    test(S("abcdefghij"), 5, 2, S("abcdehij"));
-    test(S("abcdefghij"), 5, 4, S("abcdej"));
-    test(S("abcdefghij"), 5, 5, S("abcde"));
-    test(S("abcdefghij"), 5, 6, S("abcde"));
-    test(S("abcdefghij"), 9, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 9, 1, S("abcdefghi"));
-    test(S("abcdefghij"), 9, 2, S("abcdefghi"));
-    test(S("abcdefghij"), 10, 0, S("abcdefghij"));
-    test(S("abcdefghij"), 10, 1, S("abcdefghij"));
-    test(S("abcdefghij"), 11, 0, S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 1, S("bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, S("klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 19, S("t"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, S(""));
-    test(S("abcdefghijklmnopqrst"), 0, 21, S(""));
-    test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 1, S("acdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 9, S("aklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 18, S("at"));
-    test(S("abcdefghijklmnopqrst"), 1, 19, S("a"));
-    test(S("abcdefghijklmnopqrst"), 1, 20, S("a"));
-    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"), 10, 11, S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
-    test(S("abcdefghijklmnopqrst"), 19, 2, S("abcdefghijklmnopqrs"));
-    test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 21, 0, S("can't happen"));
 
-    test(S(""), 0, S(""));
-    test(S(""), 1, S("can't happen"));
-    test(S("abcde"), 0, S(""));
-    test(S("abcde"), 1, S("a"));
-    test(S("abcde"), 2, S("ab"));
-    test(S("abcde"), 4, S("abcd"));
-    test(S("abcde"), 5, S("abcde"));
-    test(S("abcde"), 6, S("can't happen"));
-    test(S("abcdefghij"), 0, S(""));
-    test(S("abcdefghij"), 1, S("a"));
-    test(S("abcdefghij"), 5, S("abcde"));
-    test(S("abcdefghij"), 9, S("abcdefghi"));
-    test(S("abcdefghij"), 10, S("abcdefghij"));
-    test(S("abcdefghij"), 11, S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, S(""));
-    test(S("abcdefghijklmnopqrst"), 1, S("a"));
-    test(S("abcdefghijklmnopqrst"), 10, S("abcdefghij"));
-    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(""));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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_insert/iter_char.pass.cpp

test(S& s, typename S::const_iterator p, typename S::value_type c, S expected)
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     assert(i - s.begin() == pos);
     assert(*i == c);
     if (sufficient_cap)
         assert(i == p);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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_insert/iter_iter_iter.pass.cpp

test_exceptions(S s, typename S::difference_type pos, 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
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S("12345"), 0, s, s, S("12345"));
-    test(S("12345"), 1, s, s+1, S("1A2345"));
-    test(S("12345"), 4, s, s+10, S("1234ABCDEFGHIJ5"));
-    test(S("12345"), 5, s, s+52, S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), 0, s, s, S("1234567890"));
-    test(S("1234567890"), 1, s, s+1, S("1A234567890"));
-    test(S("1234567890"), 10, s, s+10, S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
 
-    test(S("12345678901234567890"), 3, s, s, S("12345678901234567890"));
-    test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890"));
-    test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890"));
-    test(S("12345678901234567890"), 20, s, s+52,
-         S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345"));
-    test(S("12345"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A2345"));
-    test(S("12345"), 4, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
-    test(S("12345"), 5, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("1234567890"));
-    test(S("1234567890"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A234567890"));
-    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"));
-    test(S("12345"), 1, s, s+1, S("1A2345"));
-    test(S("12345"), 4, s, s+10, S("1234ABCDEFGHIJ5"));
-    test(S("12345"), 5, s, s+52, S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), 0, s, s, S("1234567890"));
-    test(S("1234567890"), 1, s, s+1, S("1A234567890"));
-    test(S("1234567890"), 10, s, s+10, S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
-
-    test(S("12345678901234567890"), 3, s, s, S("12345678901234567890"));
-    test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890"));
-    test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890"));
-    test(S("12345678901234567890"), 20, s, s+52,
-         S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
-    test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("12345"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345"));
-    test(S("12345"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A2345"));
-    test(S("12345"), 4, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
-    test(S("12345"), 5, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("1234567890"));
-    test(S("1234567890"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A234567890"));
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // 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()));
#endif
   { // 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.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

 {
     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);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-    test(S("abcde"), 0, 20, '1', S("11111111111111111111abcde"));
-    test(S("abcde"), 1, 0, '1', S("abcde"));
-    test(S("abcde"), 1, 5, '1', S("a11111bcde"));
-    test(S("abcde"), 1, 10, '1', S("a1111111111bcde"));
-    test(S("abcde"), 1, 20, '1', S("a11111111111111111111bcde"));
-    test(S("abcde"), 2, 0, '1', S("abcde"));
-    test(S("abcde"), 2, 5, '1', S("ab11111cde"));
-    test(S("abcde"), 2, 10, '1', S("ab1111111111cde"));
-    test(S("abcde"), 2, 20, '1', S("ab11111111111111111111cde"));
-    test(S("abcde"), 4, 0, '1', S("abcde"));
-    test(S("abcde"), 4, 5, '1', S("abcd11111e"));
-    test(S("abcde"), 4, 10, '1', S("abcd1111111111e"));
-    test(S("abcde"), 4, 20, '1', S("abcd11111111111111111111e"));
-    test(S("abcde"), 5, 0, '1', S("abcde"));
-    test(S("abcde"), 5, 5, '1', S("abcde11111"));
-    test(S("abcde"), 5, 10, '1', S("abcde1111111111"));
-    test(S("abcde"), 5, 20, '1', S("abcde11111111111111111111"));
-    test(S("abcdefghij"), 0, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 0, 5, '1', S("11111abcdefghij"));
-    test(S("abcdefghij"), 0, 10, '1', S("1111111111abcdefghij"));
-    test(S("abcdefghij"), 0, 20, '1', S("11111111111111111111abcdefghij"));
-    test(S("abcdefghij"), 1, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 1, 5, '1', S("a11111bcdefghij"));
-    test(S("abcdefghij"), 1, 10, '1', S("a1111111111bcdefghij"));
-    test(S("abcdefghij"), 1, 20, '1', S("a11111111111111111111bcdefghij"));
-    test(S("abcdefghij"), 5, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 5, 5, '1', S("abcde11111fghij"));
-    test(S("abcdefghij"), 5, 10, '1', S("abcde1111111111fghij"));
-    test(S("abcdefghij"), 5, 20, '1', S("abcde11111111111111111111fghij"));
-    test(S("abcdefghij"), 9, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 9, 5, '1', S("abcdefghi11111j"));
-    test(S("abcdefghij"), 9, 10, '1', S("abcdefghi1111111111j"));
-    test(S("abcdefghij"), 9, 20, '1', S("abcdefghi11111111111111111111j"));
-    test(S("abcdefghij"), 10, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 10, 5, '1', S("abcdefghij11111"));
-    test(S("abcdefghij"), 10, 10, '1', S("abcdefghij1111111111"));
-    test(S("abcdefghij"), 10, 20, '1', S("abcdefghij11111111111111111111"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 5, '1', S("11111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, '1', S("1111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, '1', S("11111111111111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 5, '1', S("a11111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 10, '1', S("a1111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 20, '1', S("a11111111111111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 5, '1', S("abcdefghij11111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 10, '1', S("abcdefghij1111111111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 20, '1', S("abcdefghij11111111111111111111klmnopqrst"));
-    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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-    test(S("abcde"), 0, 20, '1', S("11111111111111111111abcde"));
-    test(S("abcde"), 1, 0, '1', S("abcde"));
-    test(S("abcde"), 1, 5, '1', S("a11111bcde"));
-    test(S("abcde"), 1, 10, '1', S("a1111111111bcde"));
-    test(S("abcde"), 1, 20, '1', S("a11111111111111111111bcde"));
-    test(S("abcde"), 2, 0, '1', S("abcde"));
-    test(S("abcde"), 2, 5, '1', S("ab11111cde"));
-    test(S("abcde"), 2, 10, '1', S("ab1111111111cde"));
-    test(S("abcde"), 2, 20, '1', S("ab11111111111111111111cde"));
-    test(S("abcde"), 4, 0, '1', S("abcde"));
-    test(S("abcde"), 4, 5, '1', S("abcd11111e"));
-    test(S("abcde"), 4, 10, '1', S("abcd1111111111e"));
-    test(S("abcde"), 4, 20, '1', S("abcd11111111111111111111e"));
-    test(S("abcde"), 5, 0, '1', S("abcde"));
-    test(S("abcde"), 5, 5, '1', S("abcde11111"));
-    test(S("abcde"), 5, 10, '1', S("abcde1111111111"));
-    test(S("abcde"), 5, 20, '1', S("abcde11111111111111111111"));
-    test(S("abcdefghij"), 0, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 0, 5, '1', S("11111abcdefghij"));
-    test(S("abcdefghij"), 0, 10, '1', S("1111111111abcdefghij"));
-    test(S("abcdefghij"), 0, 20, '1', S("11111111111111111111abcdefghij"));
-    test(S("abcdefghij"), 1, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 1, 5, '1', S("a11111bcdefghij"));
-    test(S("abcdefghij"), 1, 10, '1', S("a1111111111bcdefghij"));
-    test(S("abcdefghij"), 1, 20, '1', S("a11111111111111111111bcdefghij"));
-    test(S("abcdefghij"), 5, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 5, 5, '1', S("abcde11111fghij"));
-    test(S("abcdefghij"), 5, 10, '1', S("abcde1111111111fghij"));
-    test(S("abcdefghij"), 5, 20, '1', S("abcde11111111111111111111fghij"));
-    test(S("abcdefghij"), 9, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 9, 5, '1', S("abcdefghi11111j"));
-    test(S("abcdefghij"), 9, 10, '1', S("abcdefghi1111111111j"));
-    test(S("abcdefghij"), 9, 20, '1', S("abcdefghi11111111111111111111j"));
-    test(S("abcdefghij"), 10, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 10, 5, '1', S("abcdefghij11111"));
-    test(S("abcdefghij"), 10, 10, '1', S("abcdefghij1111111111"));
-    test(S("abcdefghij"), 10, 20, '1', S("abcdefghij11111111111111111111"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 5, '1', S("11111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, '1', S("1111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, '1', S("11111111111111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 5, '1', S("a11111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 10, '1', S("a1111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 20, '1', S("a11111111111111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 5, '1', S("abcdefghij11111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 10, '1', S("abcdefghij1111111111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 20, '1', S("abcdefghij11111111111111111111klmnopqrst"));
-    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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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_insert/size_pointer.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-    test(S(""), 1, "12345678901234567890", S("can't happen"));
-    test(S("abcde"), 0, "", S("abcde"));
-    test(S("abcde"), 0, "12345", S("12345abcde"));
-    test(S("abcde"), 0, "1234567890", S("1234567890abcde"));
-    test(S("abcde"), 0, "12345678901234567890", S("12345678901234567890abcde"));
-    test(S("abcde"), 1, "", S("abcde"));
-    test(S("abcde"), 1, "12345", S("a12345bcde"));
-    test(S("abcde"), 1, "1234567890", S("a1234567890bcde"));
-    test(S("abcde"), 1, "12345678901234567890", S("a12345678901234567890bcde"));
-    test(S("abcde"), 2, "", S("abcde"));
-    test(S("abcde"), 2, "12345", S("ab12345cde"));
-    test(S("abcde"), 2, "1234567890", S("ab1234567890cde"));
-    test(S("abcde"), 2, "12345678901234567890", S("ab12345678901234567890cde"));
-    test(S("abcde"), 4, "", S("abcde"));
-    test(S("abcde"), 4, "12345", S("abcd12345e"));
-    test(S("abcde"), 4, "1234567890", S("abcd1234567890e"));
-    test(S("abcde"), 4, "12345678901234567890", S("abcd12345678901234567890e"));
-    test(S("abcde"), 5, "", S("abcde"));
-    test(S("abcde"), 5, "12345", S("abcde12345"));
-    test(S("abcde"), 5, "1234567890", S("abcde1234567890"));
-    test(S("abcde"), 5, "12345678901234567890", S("abcde12345678901234567890"));
-    test(S("abcde"), 6, "", S("can't happen"));
-    test(S("abcde"), 6, "12345", S("can't happen"));
-    test(S("abcde"), 6, "1234567890", S("can't happen"));
-    test(S("abcde"), 6, "12345678901234567890", S("can't happen"));
-    test(S("abcdefghij"), 0, "", S("abcdefghij"));
-    test(S("abcdefghij"), 0, "12345", S("12345abcdefghij"));
-    test(S("abcdefghij"), 0, "1234567890", S("1234567890abcdefghij"));
-    test(S("abcdefghij"), 0, "12345678901234567890", S("12345678901234567890abcdefghij"));
-    test(S("abcdefghij"), 1, "", S("abcdefghij"));
-    test(S("abcdefghij"), 1, "12345", S("a12345bcdefghij"));
-    test(S("abcdefghij"), 1, "1234567890", S("a1234567890bcdefghij"));
-    test(S("abcdefghij"), 1, "12345678901234567890", S("a12345678901234567890bcdefghij"));
-    test(S("abcdefghij"), 5, "", S("abcdefghij"));
-    test(S("abcdefghij"), 5, "12345", S("abcde12345fghij"));
-    test(S("abcdefghij"), 5, "1234567890", S("abcde1234567890fghij"));
-    test(S("abcdefghij"), 5, "12345678901234567890", S("abcde12345678901234567890fghij"));
-    test(S("abcdefghij"), 9, "", S("abcdefghij"));
-    test(S("abcdefghij"), 9, "12345", S("abcdefghi12345j"));
-    test(S("abcdefghij"), 9, "1234567890", S("abcdefghi1234567890j"));
-    test(S("abcdefghij"), 9, "12345678901234567890", S("abcdefghi12345678901234567890j"));
-    test(S("abcdefghij"), 10, "", S("abcdefghij"));
-    test(S("abcdefghij"), 10, "12345", S("abcdefghij12345"));
-    test(S("abcdefghij"), 10, "1234567890", S("abcdefghij1234567890"));
-    test(S("abcdefghij"), 10, "12345678901234567890", S("abcdefghij12345678901234567890"));
-    test(S("abcdefghij"), 11, "", S("can't happen"));
-    test(S("abcdefghij"), 11, "12345", S("can't happen"));
-    test(S("abcdefghij"), 11, "1234567890", S("can't happen"));
-    test(S("abcdefghij"), 11, "12345678901234567890", S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, "12345", S("12345abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, "1234567890", S("1234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, "12345678901234567890", S("12345678901234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "12345", S("a12345bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "1234567890", S("a1234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "12345678901234567890", S("a12345678901234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "12345", S("abcdefghij12345klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "1234567890", S("abcdefghij1234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "12345678901234567890", S("abcdefghij12345678901234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, "12345", S("abcdefghijklmnopqrs12345t"));
-    test(S("abcdefghijklmnopqrst"), 19, "1234567890", S("abcdefghijklmnopqrs1234567890t"));
-    test(S("abcdefghijklmnopqrst"), 19, "12345678901234567890", S("abcdefghijklmnopqrs12345678901234567890t"));
-    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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-    test(S(""), 1, "12345678901234567890", S("can't happen"));
-    test(S("abcde"), 0, "", S("abcde"));
-    test(S("abcde"), 0, "12345", S("12345abcde"));
-    test(S("abcde"), 0, "1234567890", S("1234567890abcde"));
-    test(S("abcde"), 0, "12345678901234567890", S("12345678901234567890abcde"));
-    test(S("abcde"), 1, "", S("abcde"));
-    test(S("abcde"), 1, "12345", S("a12345bcde"));
-    test(S("abcde"), 1, "1234567890", S("a1234567890bcde"));
-    test(S("abcde"), 1, "12345678901234567890", S("a12345678901234567890bcde"));
-    test(S("abcde"), 2, "", S("abcde"));
-    test(S("abcde"), 2, "12345", S("ab12345cde"));
-    test(S("abcde"), 2, "1234567890", S("ab1234567890cde"));
-    test(S("abcde"), 2, "12345678901234567890", S("ab12345678901234567890cde"));
-    test(S("abcde"), 4, "", S("abcde"));
-    test(S("abcde"), 4, "12345", S("abcd12345e"));
-    test(S("abcde"), 4, "1234567890", S("abcd1234567890e"));
-    test(S("abcde"), 4, "12345678901234567890", S("abcd12345678901234567890e"));
-    test(S("abcde"), 5, "", S("abcde"));
-    test(S("abcde"), 5, "12345", S("abcde12345"));
-    test(S("abcde"), 5, "1234567890", S("abcde1234567890"));
-    test(S("abcde"), 5, "12345678901234567890", S("abcde12345678901234567890"));
-    test(S("abcde"), 6, "", S("can't happen"));
-    test(S("abcde"), 6, "12345", S("can't happen"));
-    test(S("abcde"), 6, "1234567890", S("can't happen"));
-    test(S("abcde"), 6, "12345678901234567890", S("can't happen"));
-    test(S("abcdefghij"), 0, "", S("abcdefghij"));
-    test(S("abcdefghij"), 0, "12345", S("12345abcdefghij"));
-    test(S("abcdefghij"), 0, "1234567890", S("1234567890abcdefghij"));
-    test(S("abcdefghij"), 0, "12345678901234567890", S("12345678901234567890abcdefghij"));
-    test(S("abcdefghij"), 1, "", S("abcdefghij"));
-    test(S("abcdefghij"), 1, "12345", S("a12345bcdefghij"));
-    test(S("abcdefghij"), 1, "1234567890", S("a1234567890bcdefghij"));
-    test(S("abcdefghij"), 1, "12345678901234567890", S("a12345678901234567890bcdefghij"));
-    test(S("abcdefghij"), 5, "", S("abcdefghij"));
-    test(S("abcdefghij"), 5, "12345", S("abcde12345fghij"));
-    test(S("abcdefghij"), 5, "1234567890", S("abcde1234567890fghij"));
-    test(S("abcdefghij"), 5, "12345678901234567890", S("abcde12345678901234567890fghij"));
-    test(S("abcdefghij"), 9, "", S("abcdefghij"));
-    test(S("abcdefghij"), 9, "12345", S("abcdefghi12345j"));
-    test(S("abcdefghij"), 9, "1234567890", S("abcdefghi1234567890j"));
-    test(S("abcdefghij"), 9, "12345678901234567890", S("abcdefghi12345678901234567890j"));
-    test(S("abcdefghij"), 10, "", S("abcdefghij"));
-    test(S("abcdefghij"), 10, "12345", S("abcdefghij12345"));
-    test(S("abcdefghij"), 10, "1234567890", S("abcdefghij1234567890"));
-    test(S("abcdefghij"), 10, "12345678901234567890", S("abcdefghij12345678901234567890"));
-    test(S("abcdefghij"), 11, "", S("can't happen"));
-    test(S("abcdefghij"), 11, "12345", S("can't happen"));
-    test(S("abcdefghij"), 11, "1234567890", S("can't happen"));
-    test(S("abcdefghij"), 11, "12345678901234567890", S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, "12345", S("12345abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, "1234567890", S("1234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, "12345678901234567890", S("12345678901234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "12345", S("a12345bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "1234567890", S("a1234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, "12345678901234567890", S("a12345678901234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "12345", S("abcdefghij12345klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "1234567890", S("abcdefghij1234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, "12345678901234567890", S("abcdefghij12345678901234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, "", S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, "12345", S("abcdefghijklmnopqrs12345t"));
-    test(S("abcdefghijklmnopqrst"), 19, "1234567890", S("abcdefghijklmnopqrs1234567890t"));
-    test(S("abcdefghijklmnopqrst"), 19, "12345678901234567890", S("abcdefghijklmnopqrs12345678901234567890t"));
-    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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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());

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

else if (!TEST_IS_CONSTANT_EVALUATED)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-    test(S(""), 1, 20, '1', S("can't happen"));
-    test(S("abcde"), 0, 0, '1', S("abcde"));
-    test(S("abcde"), 0, 5, '1', S("11111abcde"));
-    test(S("abcde"), 0, 10, '1', S("1111111111abcde"));
-    test(S("abcde"), 0, 20, '1', S("11111111111111111111abcde"));
-    test(S("abcde"), 1, 0, '1', S("abcde"));
-    test(S("abcde"), 1, 5, '1', S("a11111bcde"));
-    test(S("abcde"), 1, 10, '1', S("a1111111111bcde"));
-    test(S("abcde"), 1, 20, '1', S("a11111111111111111111bcde"));
-    test(S("abcde"), 2, 0, '1', S("abcde"));
-    test(S("abcde"), 2, 5, '1', S("ab11111cde"));
-    test(S("abcde"), 2, 10, '1', S("ab1111111111cde"));
-    test(S("abcde"), 2, 20, '1', S("ab11111111111111111111cde"));
-    test(S("abcde"), 4, 0, '1', S("abcde"));
-    test(S("abcde"), 4, 5, '1', S("abcd11111e"));
-    test(S("abcde"), 4, 10, '1', S("abcd1111111111e"));
-    test(S("abcde"), 4, 20, '1', S("abcd11111111111111111111e"));
-    test(S("abcde"), 5, 0, '1', S("abcde"));
-    test(S("abcde"), 5, 5, '1', S("abcde11111"));
-    test(S("abcde"), 5, 10, '1', S("abcde1111111111"));
-    test(S("abcde"), 5, 20, '1', S("abcde11111111111111111111"));
-    test(S("abcde"), 6, 0, '1', S("can't happen"));
-    test(S("abcde"), 6, 5, '1', S("can't happen"));
-    test(S("abcde"), 6, 10, '1', S("can't happen"));
-    test(S("abcde"), 6, 20, '1', S("can't happen"));
-    test(S("abcdefghij"), 0, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 0, 5, '1', S("11111abcdefghij"));
-    test(S("abcdefghij"), 0, 10, '1', S("1111111111abcdefghij"));
-    test(S("abcdefghij"), 0, 20, '1', S("11111111111111111111abcdefghij"));
-    test(S("abcdefghij"), 1, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 1, 5, '1', S("a11111bcdefghij"));
-    test(S("abcdefghij"), 1, 10, '1', S("a1111111111bcdefghij"));
-    test(S("abcdefghij"), 1, 20, '1', S("a11111111111111111111bcdefghij"));
-    test(S("abcdefghij"), 5, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 5, 5, '1', S("abcde11111fghij"));
-    test(S("abcdefghij"), 5, 10, '1', S("abcde1111111111fghij"));
-    test(S("abcdefghij"), 5, 20, '1', S("abcde11111111111111111111fghij"));
-    test(S("abcdefghij"), 9, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 9, 5, '1', S("abcdefghi11111j"));
-    test(S("abcdefghij"), 9, 10, '1', S("abcdefghi1111111111j"));
-    test(S("abcdefghij"), 9, 20, '1', S("abcdefghi11111111111111111111j"));
-    test(S("abcdefghij"), 10, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 10, 5, '1', S("abcdefghij11111"));
-    test(S("abcdefghij"), 10, 10, '1', S("abcdefghij1111111111"));
-    test(S("abcdefghij"), 10, 20, '1', S("abcdefghij11111111111111111111"));
-    test(S("abcdefghij"), 11, 0, '1', S("can't happen"));
-    test(S("abcdefghij"), 11, 5, '1', S("can't happen"));
-    test(S("abcdefghij"), 11, 10, '1', S("can't happen"));
-    test(S("abcdefghij"), 11, 20, '1', S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 5, '1', S("11111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, '1', S("1111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, '1', S("11111111111111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 5, '1', S("a11111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 10, '1', S("a1111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 20, '1', S("a11111111111111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 5, '1', S("abcdefghij11111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 10, '1', S("abcdefghij1111111111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 20, '1', S("abcdefghij11111111111111111111klmnopqrst"));
-    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"));
-    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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-    test(S(""), 1, 20, '1', S("can't happen"));
-    test(S("abcde"), 0, 0, '1', S("abcde"));
-    test(S("abcde"), 0, 5, '1', S("11111abcde"));
-    test(S("abcde"), 0, 10, '1', S("1111111111abcde"));
-    test(S("abcde"), 0, 20, '1', S("11111111111111111111abcde"));
-    test(S("abcde"), 1, 0, '1', S("abcde"));
-    test(S("abcde"), 1, 5, '1', S("a11111bcde"));
-    test(S("abcde"), 1, 10, '1', S("a1111111111bcde"));
-    test(S("abcde"), 1, 20, '1', S("a11111111111111111111bcde"));
-    test(S("abcde"), 2, 0, '1', S("abcde"));
-    test(S("abcde"), 2, 5, '1', S("ab11111cde"));
-    test(S("abcde"), 2, 10, '1', S("ab1111111111cde"));
-    test(S("abcde"), 2, 20, '1', S("ab11111111111111111111cde"));
-    test(S("abcde"), 4, 0, '1', S("abcde"));
-    test(S("abcde"), 4, 5, '1', S("abcd11111e"));
-    test(S("abcde"), 4, 10, '1', S("abcd1111111111e"));
-    test(S("abcde"), 4, 20, '1', S("abcd11111111111111111111e"));
-    test(S("abcde"), 5, 0, '1', S("abcde"));
-    test(S("abcde"), 5, 5, '1', S("abcde11111"));
-    test(S("abcde"), 5, 10, '1', S("abcde1111111111"));
-    test(S("abcde"), 5, 20, '1', S("abcde11111111111111111111"));
-    test(S("abcde"), 6, 0, '1', S("can't happen"));
-    test(S("abcde"), 6, 5, '1', S("can't happen"));
-    test(S("abcde"), 6, 10, '1', S("can't happen"));
-    test(S("abcde"), 6, 20, '1', S("can't happen"));
-    test(S("abcdefghij"), 0, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 0, 5, '1', S("11111abcdefghij"));
-    test(S("abcdefghij"), 0, 10, '1', S("1111111111abcdefghij"));
-    test(S("abcdefghij"), 0, 20, '1', S("11111111111111111111abcdefghij"));
-    test(S("abcdefghij"), 1, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 1, 5, '1', S("a11111bcdefghij"));
-    test(S("abcdefghij"), 1, 10, '1', S("a1111111111bcdefghij"));
-    test(S("abcdefghij"), 1, 20, '1', S("a11111111111111111111bcdefghij"));
-    test(S("abcdefghij"), 5, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 5, 5, '1', S("abcde11111fghij"));
-    test(S("abcdefghij"), 5, 10, '1', S("abcde1111111111fghij"));
-    test(S("abcdefghij"), 5, 20, '1', S("abcde11111111111111111111fghij"));
-    test(S("abcdefghij"), 9, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 9, 5, '1', S("abcdefghi11111j"));
-    test(S("abcdefghij"), 9, 10, '1', S("abcdefghi1111111111j"));
-    test(S("abcdefghij"), 9, 20, '1', S("abcdefghi11111111111111111111j"));
-    test(S("abcdefghij"), 10, 0, '1', S("abcdefghij"));
-    test(S("abcdefghij"), 10, 5, '1', S("abcdefghij11111"));
-    test(S("abcdefghij"), 10, 10, '1', S("abcdefghij1111111111"));
-    test(S("abcdefghij"), 10, 20, '1', S("abcdefghij11111111111111111111"));
-    test(S("abcdefghij"), 11, 0, '1', S("can't happen"));
-    test(S("abcdefghij"), 11, 5, '1', S("can't happen"));
-    test(S("abcdefghij"), 11, 10, '1', S("can't happen"));
-    test(S("abcdefghij"), 11, 20, '1', S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 5, '1', S("11111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 10, '1', S("1111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, 20, '1', S("11111111111111111111abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 5, '1', S("a11111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 10, '1', S("a1111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, 20, '1', S("a11111111111111111111bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 0, '1', S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 5, '1', S("abcdefghij11111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 10, '1', S("abcdefghij1111111111klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, 20, '1', S("abcdefghij11111111111111111111klmnopqrst"));
-    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"));
-    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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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_insert/size_string.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-    test(S(""), 1, S("12345678901234567890"), S("can't happen"));
-    test(S("abcde"), 0, S(""), S("abcde"));
-    test(S("abcde"), 0, S("12345"), S("12345abcde"));
-    test(S("abcde"), 0, S("1234567890"), S("1234567890abcde"));
-    test(S("abcde"), 0, S("12345678901234567890"), S("12345678901234567890abcde"));
-    test(S("abcde"), 1, S(""), S("abcde"));
-    test(S("abcde"), 1, S("12345"), S("a12345bcde"));
-    test(S("abcde"), 1, S("1234567890"), S("a1234567890bcde"));
-    test(S("abcde"), 1, S("12345678901234567890"), S("a12345678901234567890bcde"));
-    test(S("abcde"), 2, S(""), S("abcde"));
-    test(S("abcde"), 2, S("12345"), S("ab12345cde"));
-    test(S("abcde"), 2, S("1234567890"), S("ab1234567890cde"));
-    test(S("abcde"), 2, S("12345678901234567890"), S("ab12345678901234567890cde"));
-    test(S("abcde"), 4, S(""), S("abcde"));
-    test(S("abcde"), 4, S("12345"), S("abcd12345e"));
-    test(S("abcde"), 4, S("1234567890"), S("abcd1234567890e"));
-    test(S("abcde"), 4, S("12345678901234567890"), S("abcd12345678901234567890e"));
-    test(S("abcde"), 5, S(""), S("abcde"));
-    test(S("abcde"), 5, S("12345"), S("abcde12345"));
-    test(S("abcde"), 5, S("1234567890"), S("abcde1234567890"));
-    test(S("abcde"), 5, S("12345678901234567890"), S("abcde12345678901234567890"));
-    test(S("abcde"), 6, S(""), S("can't happen"));
-    test(S("abcde"), 6, S("12345"), S("can't happen"));
-    test(S("abcde"), 6, S("1234567890"), S("can't happen"));
-    test(S("abcde"), 6, S("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghij"), 0, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 0, S("12345"), S("12345abcdefghij"));
-    test(S("abcdefghij"), 0, S("1234567890"), S("1234567890abcdefghij"));
-    test(S("abcdefghij"), 0, S("12345678901234567890"), S("12345678901234567890abcdefghij"));
-    test(S("abcdefghij"), 1, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 1, S("12345"), S("a12345bcdefghij"));
-    test(S("abcdefghij"), 1, S("1234567890"), S("a1234567890bcdefghij"));
-    test(S("abcdefghij"), 1, S("12345678901234567890"), S("a12345678901234567890bcdefghij"));
-    test(S("abcdefghij"), 5, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 5, S("12345"), S("abcde12345fghij"));
-    test(S("abcdefghij"), 5, S("1234567890"), S("abcde1234567890fghij"));
-    test(S("abcdefghij"), 5, S("12345678901234567890"), S("abcde12345678901234567890fghij"));
-    test(S("abcdefghij"), 9, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 9, S("12345"), S("abcdefghi12345j"));
-    test(S("abcdefghij"), 9, S("1234567890"), S("abcdefghi1234567890j"));
-    test(S("abcdefghij"), 9, S("12345678901234567890"), S("abcdefghi12345678901234567890j"));
-    test(S("abcdefghij"), 10, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 10, S("12345"), S("abcdefghij12345"));
-    test(S("abcdefghij"), 10, S("1234567890"), S("abcdefghij1234567890"));
-    test(S("abcdefghij"), 10, S("12345678901234567890"), S("abcdefghij12345678901234567890"));
-    test(S("abcdefghij"), 11, S(""), S("can't happen"));
-    test(S("abcdefghij"), 11, S("12345"), S("can't happen"));
-    test(S("abcdefghij"), 11, S("1234567890"), S("can't happen"));
-    test(S("abcdefghij"), 11, S("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, S("12345"), S("12345abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, S("1234567890"), S("1234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S("12345"), S("a12345bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S("12345"), S("abcdefghij12345klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S("1234567890"), S("abcdefghij1234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, S("12345"), S("abcdefghijklmnopqrs12345t"));
-    test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
-    test(S("abcdefghijklmnopqrst"), 19, S("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
-    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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-    test(S(""), 1, S("12345678901234567890"), S("can't happen"));
-    test(S("abcde"), 0, S(""), S("abcde"));
-    test(S("abcde"), 0, S("12345"), S("12345abcde"));
-    test(S("abcde"), 0, S("1234567890"), S("1234567890abcde"));
-    test(S("abcde"), 0, S("12345678901234567890"), S("12345678901234567890abcde"));
-    test(S("abcde"), 1, S(""), S("abcde"));
-    test(S("abcde"), 1, S("12345"), S("a12345bcde"));
-    test(S("abcde"), 1, S("1234567890"), S("a1234567890bcde"));
-    test(S("abcde"), 1, S("12345678901234567890"), S("a12345678901234567890bcde"));
-    test(S("abcde"), 2, S(""), S("abcde"));
-    test(S("abcde"), 2, S("12345"), S("ab12345cde"));
-    test(S("abcde"), 2, S("1234567890"), S("ab1234567890cde"));
-    test(S("abcde"), 2, S("12345678901234567890"), S("ab12345678901234567890cde"));
-    test(S("abcde"), 4, S(""), S("abcde"));
-    test(S("abcde"), 4, S("12345"), S("abcd12345e"));
-    test(S("abcde"), 4, S("1234567890"), S("abcd1234567890e"));
-    test(S("abcde"), 4, S("12345678901234567890"), S("abcd12345678901234567890e"));
-    test(S("abcde"), 5, S(""), S("abcde"));
-    test(S("abcde"), 5, S("12345"), S("abcde12345"));
-    test(S("abcde"), 5, S("1234567890"), S("abcde1234567890"));
-    test(S("abcde"), 5, S("12345678901234567890"), S("abcde12345678901234567890"));
-    test(S("abcde"), 6, S(""), S("can't happen"));
-    test(S("abcde"), 6, S("12345"), S("can't happen"));
-    test(S("abcde"), 6, S("1234567890"), S("can't happen"));
-    test(S("abcde"), 6, S("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghij"), 0, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 0, S("12345"), S("12345abcdefghij"));
-    test(S("abcdefghij"), 0, S("1234567890"), S("1234567890abcdefghij"));
-    test(S("abcdefghij"), 0, S("12345678901234567890"), S("12345678901234567890abcdefghij"));
-    test(S("abcdefghij"), 1, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 1, S("12345"), S("a12345bcdefghij"));
-    test(S("abcdefghij"), 1, S("1234567890"), S("a1234567890bcdefghij"));
-    test(S("abcdefghij"), 1, S("12345678901234567890"), S("a12345678901234567890bcdefghij"));
-    test(S("abcdefghij"), 5, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 5, S("12345"), S("abcde12345fghij"));
-    test(S("abcdefghij"), 5, S("1234567890"), S("abcde1234567890fghij"));
-    test(S("abcdefghij"), 5, S("12345678901234567890"), S("abcde12345678901234567890fghij"));
-    test(S("abcdefghij"), 9, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 9, S("12345"), S("abcdefghi12345j"));
-    test(S("abcdefghij"), 9, S("1234567890"), S("abcdefghi1234567890j"));
-    test(S("abcdefghij"), 9, S("12345678901234567890"), S("abcdefghi12345678901234567890j"));
-    test(S("abcdefghij"), 10, S(""), S("abcdefghij"));
-    test(S("abcdefghij"), 10, S("12345"), S("abcdefghij12345"));
-    test(S("abcdefghij"), 10, S("1234567890"), S("abcdefghij1234567890"));
-    test(S("abcdefghij"), 10, S("12345678901234567890"), S("abcdefghij12345678901234567890"));
-    test(S("abcdefghij"), 11, S(""), S("can't happen"));
-    test(S("abcdefghij"), 11, S("12345"), S("can't happen"));
-    test(S("abcdefghij"), 11, S("1234567890"), S("can't happen"));
-    test(S("abcdefghij"), 11, S("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, S("12345"), S("12345abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, S("1234567890"), S("1234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S("12345"), S("a12345bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, S("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S("12345"), S("abcdefghij12345klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S("1234567890"), S("abcdefghij1234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, S(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, S("12345"), S("abcdefghijklmnopqrs12345t"));
-    test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
-    test(S("abcdefghijklmnopqrst"), 19, S("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
-    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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
 #if TEST_STD_VER > 3
   {   // LWG 2946
     std::string s;
     s.insert(0, {"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");

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

else if (!TEST_IS_CONSTANT_EVALUATED)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-    test(S(""), 1, SV("1234567890"), S("can't happen"));
-    test(S(""), 1, SV("12345678901234567890"), S("can't happen"));
-    test(S("abcde"), 0, SV(""), S("abcde"));
-    test(S("abcde"), 0, SV("12345"), S("12345abcde"));
-    test(S("abcde"), 0, SV("1234567890"), S("1234567890abcde"));
-    test(S("abcde"), 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
-    test(S("abcde"), 1, SV(""), S("abcde"));
-    test(S("abcde"), 1, SV("12345"), S("a12345bcde"));
-    test(S("abcde"), 1, SV("1234567890"), S("a1234567890bcde"));
-    test(S("abcde"), 1, SV("12345678901234567890"), S("a12345678901234567890bcde"));
-    test(S("abcde"), 2, SV(""), S("abcde"));
-    test(S("abcde"), 2, SV("12345"), S("ab12345cde"));
-    test(S("abcde"), 2, SV("1234567890"), S("ab1234567890cde"));
-    test(S("abcde"), 2, SV("12345678901234567890"), S("ab12345678901234567890cde"));
-    test(S("abcde"), 4, SV(""), S("abcde"));
-    test(S("abcde"), 4, SV("12345"), S("abcd12345e"));
-    test(S("abcde"), 4, SV("1234567890"), S("abcd1234567890e"));
-    test(S("abcde"), 4, SV("12345678901234567890"), S("abcd12345678901234567890e"));
-    test(S("abcde"), 5, SV(""), S("abcde"));
-    test(S("abcde"), 5, SV("12345"), S("abcde12345"));
-    test(S("abcde"), 5, SV("1234567890"), S("abcde1234567890"));
-    test(S("abcde"), 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
-    test(S("abcde"), 6, SV(""), S("can't happen"));
-    test(S("abcde"), 6, SV("12345"), S("can't happen"));
-    test(S("abcde"), 6, SV("1234567890"), S("can't happen"));
-    test(S("abcde"), 6, SV("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghij"), 0, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 0, SV("12345"), S("12345abcdefghij"));
-    test(S("abcdefghij"), 0, SV("1234567890"), S("1234567890abcdefghij"));
-    test(S("abcdefghij"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
-    test(S("abcdefghij"), 1, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 1, SV("12345"), S("a12345bcdefghij"));
-    test(S("abcdefghij"), 1, SV("1234567890"), S("a1234567890bcdefghij"));
-    test(S("abcdefghij"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
-    test(S("abcdefghij"), 5, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 5, SV("12345"), S("abcde12345fghij"));
-    test(S("abcdefghij"), 5, SV("1234567890"), S("abcde1234567890fghij"));
-    test(S("abcdefghij"), 5, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
-    test(S("abcdefghij"), 9, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 9, SV("12345"), S("abcdefghi12345j"));
-    test(S("abcdefghij"), 9, SV("1234567890"), S("abcdefghi1234567890j"));
-    test(S("abcdefghij"), 9, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
-    test(S("abcdefghij"), 10, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 10, SV("12345"), S("abcdefghij12345"));
-    test(S("abcdefghij"), 10, SV("1234567890"), S("abcdefghij1234567890"));
-    test(S("abcdefghij"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
-    test(S("abcdefghij"), 11, SV(""), S("can't happen"));
-    test(S("abcdefghij"), 11, SV("12345"), S("can't happen"));
-    test(S("abcdefghij"), 11, SV("1234567890"), S("can't happen"));
-    test(S("abcdefghij"), 11, SV("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV("12345"), S("a12345bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV("12345"), S("abcdefghij12345klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, SV("12345"), S("abcdefghijklmnopqrs12345t"));
-    test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
-    test(S("abcdefghijklmnopqrst"), 19, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
-    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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-    test(S(""), 1, SV("1234567890"), S("can't happen"));
-    test(S(""), 1, SV("12345678901234567890"), S("can't happen"));
-    test(S("abcde"), 0, SV(""), S("abcde"));
-    test(S("abcde"), 0, SV("12345"), S("12345abcde"));
-    test(S("abcde"), 0, SV("1234567890"), S("1234567890abcde"));
-    test(S("abcde"), 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
-    test(S("abcde"), 1, SV(""), S("abcde"));
-    test(S("abcde"), 1, SV("12345"), S("a12345bcde"));
-    test(S("abcde"), 1, SV("1234567890"), S("a1234567890bcde"));
-    test(S("abcde"), 1, SV("12345678901234567890"), S("a12345678901234567890bcde"));
-    test(S("abcde"), 2, SV(""), S("abcde"));
-    test(S("abcde"), 2, SV("12345"), S("ab12345cde"));
-    test(S("abcde"), 2, SV("1234567890"), S("ab1234567890cde"));
-    test(S("abcde"), 2, SV("12345678901234567890"), S("ab12345678901234567890cde"));
-    test(S("abcde"), 4, SV(""), S("abcde"));
-    test(S("abcde"), 4, SV("12345"), S("abcd12345e"));
-    test(S("abcde"), 4, SV("1234567890"), S("abcd1234567890e"));
-    test(S("abcde"), 4, SV("12345678901234567890"), S("abcd12345678901234567890e"));
-    test(S("abcde"), 5, SV(""), S("abcde"));
-    test(S("abcde"), 5, SV("12345"), S("abcde12345"));
-    test(S("abcde"), 5, SV("1234567890"), S("abcde1234567890"));
-    test(S("abcde"), 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
-    test(S("abcde"), 6, SV(""), S("can't happen"));
-    test(S("abcde"), 6, SV("12345"), S("can't happen"));
-    test(S("abcde"), 6, SV("1234567890"), S("can't happen"));
-    test(S("abcde"), 6, SV("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghij"), 0, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 0, SV("12345"), S("12345abcdefghij"));
-    test(S("abcdefghij"), 0, SV("1234567890"), S("1234567890abcdefghij"));
-    test(S("abcdefghij"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
-    test(S("abcdefghij"), 1, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 1, SV("12345"), S("a12345bcdefghij"));
-    test(S("abcdefghij"), 1, SV("1234567890"), S("a1234567890bcdefghij"));
-    test(S("abcdefghij"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
-    test(S("abcdefghij"), 5, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 5, SV("12345"), S("abcde12345fghij"));
-    test(S("abcdefghij"), 5, SV("1234567890"), S("abcde1234567890fghij"));
-    test(S("abcdefghij"), 5, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
-    test(S("abcdefghij"), 9, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 9, SV("12345"), S("abcdefghi12345j"));
-    test(S("abcdefghij"), 9, SV("1234567890"), S("abcdefghi1234567890j"));
-    test(S("abcdefghij"), 9, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
-    test(S("abcdefghij"), 10, SV(""), S("abcdefghij"));
-    test(S("abcdefghij"), 10, SV("12345"), S("abcdefghij12345"));
-    test(S("abcdefghij"), 10, SV("1234567890"), S("abcdefghij1234567890"));
-    test(S("abcdefghij"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
-    test(S("abcdefghij"), 11, SV(""), S("can't happen"));
-    test(S("abcdefghij"), 11, SV("12345"), S("can't happen"));
-    test(S("abcdefghij"), 11, SV("1234567890"), S("can't happen"));
-    test(S("abcdefghij"), 11, SV("12345678901234567890"), S("can't happen"));
-    test(S("abcdefghijklmnopqrst"), 0, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV("12345"), S("a12345bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV("12345"), S("abcdefghij12345klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, SV(""), S("abcdefghijklmnopqrst"));
-    test(S("abcdefghijklmnopqrst"), 19, SV("12345"), S("abcdefghijklmnopqrs12345t"));
-    test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
-    test(S("abcdefghijklmnopqrst"), 19, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
-    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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #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());

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp

 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), "", S());
-    test(S(), "12345", S("12345"));
-    test(S(), "1234567890", S("1234567890"));
-    test(S(), "12345678901234567890", S("12345678901234567890"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, 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_op_plus_equal/string.pass.cpp

 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
 #if TEST_STD_VER > 3
   { // LWG 2946
     std::string s;
     s += {"abc", 1};
     assert(s.size() == 1);
     assert(s == "a");

libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp

test(S s1, S s2)
     S s2_ = s2;
     s1.swap(s2);
     LIBCPP_ASSERT(s1.__invariants());
     LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s2_);
     assert(s2 == s1_);
 }
 
-TEST_CONSTEXPR_CXX20 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"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #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"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.nonmembers/string_op!=/pointer_string.pass.cpp

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

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

 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), S(""), false);
-    test(S(""), S("abcde"), true);
-    test(S(""), S("abcdefghij"), true);
-    test(S(""), S("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), S(""), true);
-    test(S("abcde"), S("abcde"), false);
-    test(S("abcde"), S("abcdefghij"), true);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), S(""), true);
-    test(S("abcdefghij"), S("abcde"), true);
-    test(S("abcdefghij"), S("abcdefghij"), false);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), S(""), true);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), S(""), false);
-    test(S(""), S("abcde"), true);
-    test(S(""), S("abcdefghij"), true);
-    test(S(""), S("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), S(""), true);
-    test(S("abcde"), S("abcde"), false);
-    test(S("abcde"), S("abcdefghij"), true);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), S(""), true);
-    test(S("abcdefghij"), S("abcde"), true);
-    test(S("abcdefghij"), S("abcdefghij"), false);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), S(""), true);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, 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.nonmembers/string_op!=/string_string_view.pass.cpp

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

 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(SV(""), S(""), false);
-    test(SV(""), S("abcde"), true);
-    test(SV(""), S("abcdefghij"), true);
-    test(SV(""), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcde"), S(""), true);
-    test(SV("abcde"), S("abcde"), false);
-    test(SV("abcde"), S("abcdefghij"), true);
-    test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghij"), S(""), true);
-    test(SV("abcdefghij"), S("abcde"), true);
-    test(SV("abcdefghij"), S("abcdefghij"), false);
-    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghijklmnopqrst"), S(""), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(SV(""), S(""), false);
-    test(SV(""), S("abcde"), true);
-    test(SV(""), S("abcdefghij"), true);
-    test(SV(""), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcde"), S(""), true);
-    test(SV("abcde"), S("abcde"), false);
-    test(SV("abcde"), S("abcdefghij"), true);
-    test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghij"), S(""), true);
-    test(SV("abcdefghij"), S("abcde"), true);
-    test(SV("abcdefghij"), S("abcdefghij"), false);
-    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghijklmnopqrst"), S(""), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }