diff --git a/libcxx/test/libcxx/strings/basic.string/string.access/assert.back.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.access/assert.back.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.access/assert.back.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.access/assert.back.pass.cpp
@@ -20,17 +20,15 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  S s;
+  TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
+}
+
 int main(int, char**) {
-    {
-        std::string s;
-        TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
-    }
-
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-        S s;
-        TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
-    }
-
-    return 0;
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.pass.cpp
@@ -20,17 +20,15 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  const S s;
+  TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
+}
+
 int main(int, char**) {
-    {
-        std::string const s;
-        TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
-    }
-
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-        const S s;
-        TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
-    }
-
-    return 0;
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.pass.cpp
@@ -20,18 +20,15 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  const S s;
+  TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string S;
-    const S s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-    const S s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.pass.cpp
@@ -21,20 +21,16 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  const S s;
+  assert(s[0] == 0);
+  TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
+}
+
 int main(int, char**) {
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-    const S s;
-    assert(s[0] == 0);
-    TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
-  }
-
-  {
-    typedef std::string S;
-    const S s;
-    assert(s[0] == 0);
-    TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.access/assert.front.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.access/assert.front.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.access/assert.front.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.access/assert.front.pass.cpp
@@ -21,18 +21,15 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  S s;
+  TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string S;
-    S s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-    S s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.access/assert.index.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.access/assert.index.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.access/assert.index.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.access/assert.index.pass.cpp
@@ -21,20 +21,16 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  S s;
+  assert(s[0] == 0);
+  TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string S;
-    S s;
-    assert(s[0] == 0);
-    TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-    S s;
-    assert(s[0] == 0);
-    TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.add.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.add.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.add.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.add.pass.cpp
@@ -19,26 +19,19 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class C>
+void test() {
+  C c(1, '\0');
+  typename C::iterator i = c.begin();
+  i += 1;
+  assert(i == c.end());
+  i = c.begin();
+  TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string C;
-    C c(1, '\0');
-    C::iterator i = c.begin();
-    i += 1;
-    assert(i == c.end());
-    i = c.begin();
-    TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
-    C c(1, '\0');
-    C::iterator i = c.begin();
-    i += 1;
-    assert(i == c.end());
-    i = c.begin();
-    TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.pass.cpp
@@ -18,20 +18,16 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  S s1;
+  S s2;
+  TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string S;
-    S s1;
-    S s2;
-    TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-    S s1;
-    S s2;
-    TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.pass.cpp
@@ -19,24 +19,18 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class C>
+void test() {
+  C c(1, '\0');
+  typename C::iterator i = c.end();
+  --i;
+  assert(i == c.begin());
+  TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string C;
-    C c(1, '\0');
-    C::iterator i = c.end();
-    --i;
-    assert(i == c.begin());
-    TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
-    C c(1, '\0');
-    C::iterator i = c.end();
-    --i;
-    assert(i == c.begin());
-    TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.pass.cpp
@@ -18,20 +18,16 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class C>
+void test() {
+  C c(1, '\0');
+  typename C::iterator i = c.end();
+  TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string C;
-    C c(1, '\0');
-    C::iterator i = c.end();
-    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
-    C c(1, '\0');
-    C::iterator i = c.end();
-    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.pass.cpp
@@ -19,24 +19,18 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class C>
+void test() {
+  C c(1, '\0');
+  typename C::iterator i = c.begin();
+  ++i;
+  assert(i == c.end());
+  TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string C;
-    C c(1, '\0');
-    C::iterator i = c.begin();
-    ++i;
-    assert(i == c.end());
-    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
-    C c(1, '\0');
-    C::iterator i = c.begin();
-    ++i;
-    assert(i == c.end());
-    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
@@ -19,23 +19,18 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+template <class C>
+void test() {
   using T = decltype(uint8_t() - uint8_t());
-  {
-    typedef std::string C;
-    C c(1, '\0');
-    C::iterator i = c.begin();
-    assert(i[0] == 0);
-    TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
-    C c(1, '\0');
-    C::iterator i = c.begin();
-    assert(i[0] == 0);
-    TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
-  }
+  C c(1, '\0');
+  typename C::iterator i = c.begin();
+  assert(i[0] == 0);
+  TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
+}
+
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.pass.cpp
@@ -18,20 +18,16 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  S s1;
+  S s2;
+  TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
+}
+
 int main(int, char**) {
-  {
-    typedef std::string S;
-    S s1;
-    S s2;
-    TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
-  }
-
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-    S s1;
-    S s2;
-    TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.erase_iter.null.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.erase_iter.null.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.erase_iter.null.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.erase_iter.null.pass.cpp
@@ -20,19 +20,16 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  S l1("123");
+  typename S::const_iterator i = l1.end();
+  TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
+}
+
 int main(int, char**) {
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-    S l1("123");
-    S::const_iterator i = l1.end();
-    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
-  }
-
-  {
-    std::string l1("123");
-    std::string::const_iterator i = l1.end();
-    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
-  }
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.pass.cpp
@@ -19,9 +19,14 @@
 
 #include "check_assertion.h"
 
+template <class S>
+void test() {
+  S s;
+  TEST_LIBCPP_ASSERT_FAILURE(s.pop_back(), "string::pop_back(): string is already empty");
+}
+
 int main(int, char**) {
-    std::string s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.pop_back(), "string::pop_back(): string is already empty");
+  test<std::string>();
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter.pass.cpp
@@ -18,21 +18,18 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
+template <class S>
+void test() {
+  S l1("123");
+  S l2("123");
+  typename S::const_iterator i = l2.begin();
+  TEST_LIBCPP_ASSERT_FAILURE(
+      l1.erase(i), "string::erase(iterator) called with an iterator not referring to this string");
+}
+
 int main(int, char**) {
-    {
-        std::string l1("123");
-        std::string l2("123");
-        std::string::const_iterator i = l2.begin();
-        TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with an iterator not referring to this string");
-    }
-
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-        S l1("123");
-        S l2("123");
-        S::const_iterator i = l2.begin();
-        TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with an iterator not referring to this string");
-    }
-
-    return 0;
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter_iter.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter_iter.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter_iter.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter_iter.pass.cpp
@@ -18,74 +18,44 @@
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
-
-    // With first iterator from another container
-    {
-        {
-            std::string l1("123");
-            std::string l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(
-                l1.erase(l2.cbegin(), l1.cbegin() + 1),
-                "string::erase(iterator,  iterator) called with an iterator not referring to this string");
-        }
-        {
-            typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-            S l1("123");
-            S l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), l1.cbegin() + 1),
-                                        "string::erase(iterator,  iterator) called with an iterator not referring to this string");
-        }
-    }
-
-    // With second iterator from another container
-    {
-        {
-            std::string l1("123");
-            std::string l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
-        }
-        {
-            typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-            S l1("123");
-            S l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
-        }
-    }
-
-    // With both iterators from another container
-    {
-        {
-            std::string l1("123");
-            std::string l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(
-                l1.erase(l2.cbegin(), l2.cbegin() + 1),
-                "string::erase(iterator,  iterator) called with an iterator not referring to this string");
-        }
-        {
-            typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-            S l1("123");
-            S l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(
-                l1.erase(l2.cbegin(), l2.cbegin() + 1),
-                "string::erase(iterator,  iterator) called with an iterator not referring to this string");
-        }
-    }
+template <class S>
+void test() {
+  // With first iterator from another container
+  {
+    S l1("123");
+    S l2("123");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), l1.cbegin() + 1),
+        "string::erase(iterator,  iterator) called with an iterator not referring to this string");
+  }
+
+  // With second iterator from another container
+  {
+    S l1("123");
+    S l2("123");
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
+  }
+
+  // With both iterators from another container
+  {
+    S l1("123");
+    S l2("123");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), l2.cbegin() + 1),
+        "string::erase(iterator,  iterator) called with an iterator not referring to this string");
+  }
+
+  // With an invalid range
+  {
+    S l1("123");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l1.cbegin() + 1, l1.cbegin()), "string::erase(first, last) called with invalid range");
+  }
+}
 
-    // With an invalid range
-    {
-        {
-            std::string l1("123");
-            TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
-                                    "string::erase(first, last) called with invalid range");
-        }
-        {
-            typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-            S l1("123");
-            TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
-                                    "string::erase(first, last) called with invalid range");
-        }
-    }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.pass.cpp
@@ -23,12 +23,17 @@
 
 #include "check_assertion.h"
 
+template <class S>
+void test() {
+  S s;
+  S s2;
+  TEST_LIBCPP_ASSERT_FAILURE(
+      s.insert(s2.begin(), '1'),
+      "string::insert(iterator, character) called with an iterator not referring to this string");
+}
+
 int main(int, char**) {
-    typedef std::string S;
-    S s;
-    S s2;
-    TEST_LIBCPP_ASSERT_FAILURE(s.insert(s2.begin(), '1'),
-        "string::insert(iterator, character) called with an iterator not referring to this string");
+  test<std::string>();
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.pass.cpp
@@ -18,13 +18,18 @@
 
 #include "check_assertion.h"
 
+template <class S>
+void test() {
+  S v;
+  S v2;
+  char a[]    = "123";
+  const int N = sizeof(a) / sizeof(a[0]);
+  TEST_LIBCPP_ASSERT_FAILURE(
+      v.insert(v2.cbegin() + 10, a, a + N), "Attempted to add/subtract an iterator outside its valid range");
+}
+
 int main(int, char**) {
-    std::string v;
-    std::string v2;
-    char a[] = "123";
-    const int N = sizeof(a)/sizeof(a[0]);
-    TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin() + 10, a, a + N),
-                               "Attempted to add/subtract an iterator outside its valid range");
-
-    return 0;
+  test<std::string>();
+
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_size_char.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_size_char.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_size_char.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_size_char.pass.cpp
@@ -17,12 +17,16 @@
 
 #include "check_assertion.h"
 
+template <class S>
+void test() {
+  S s;
+  S s2;
+  TEST_LIBCPP_ASSERT_FAILURE(s.insert(s2.begin(), 1, 'a'),
+                             "string::insert(iterator, n, value) called with an iterator not referring to this string");
+}
+
 int main(int, char**) {
-    std::string s;
-    std::string s2;
-    TEST_LIBCPP_ASSERT_FAILURE(
-        s.insert(s2.begin(), 1, 'a'),
-        "string::insert(iterator, n, value) called with an iterator not referring to this string");
+  test<std::string>();
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
@@ -22,12 +22,12 @@
   buf[size] = '\0';
 }
 
-TEST_CONSTEXPR_CXX20 void test_buffer_usage()
-{
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_buffer_usage() {
   {
     unsigned buff_size = 125;
     unsigned used_size = buff_size - 16;
-    std::string s;
+    S s;
     s.__resize_default_init(buff_size);
     write_c_str(&s[0], used_size);
     assert(s.size() == buff_size);
@@ -41,9 +41,10 @@
   }
 }
 
+template <class S>
 TEST_CONSTEXPR_CXX20 void test_basic() {
   {
-    std::string s;
+    S s;
     s.__resize_default_init(3);
     assert(s.size() == 3);
     assert(s.data()[3] == '\0');
@@ -56,17 +57,18 @@
   }
 }
 
+template <class S>
 TEST_CONSTEXPR_CXX20 bool test() {
-  test_basic();
-  test_buffer_usage();
+  test_basic<S>();
+  test_buffer_usage<S>();
 
   return true;
 }
 
 int main(int, char**) {
-  test();
+  test<std::string>();
 #if TEST_STD_VER > 17
-  static_assert(test());
+  static_assert(test<std::string>());
 #endif
 
   return 0;
diff --git a/libcxx/test/libcxx/strings/char.traits/char.traits.specializations/arbitrary_char_type.deprecated.verify.cpp b/libcxx/test/libcxx/strings/char.traits/char.traits.specializations/arbitrary_char_type.deprecated.verify.cpp
--- a/libcxx/test/libcxx/strings/char.traits/char.traits.specializations/arbitrary_char_type.deprecated.verify.cpp
+++ b/libcxx/test/libcxx/strings/char.traits/char.traits.specializations/arbitrary_char_type.deprecated.verify.cpp
@@ -15,7 +15,10 @@
 #include <string>
 
 void f() {
-    std::char_traits<unsigned char> t1; (void)t1; // expected-warning{{'char_traits<unsigned char>' is deprecated}}
-    std::char_traits<signed char> t2; (void)t2; // expected-warning{{'char_traits<signed char>' is deprecated}}
-    std::char_traits<unsigned long> t3; (void)t3; // expected-warning{{'char_traits<unsigned long>' is deprecated}}
+  std::char_traits<unsigned char> t1; // expected-warning{{'char_traits<unsigned char>' is deprecated}}
+  std::char_traits<signed char> t2;   // expected-warning{{'char_traits<signed char>' is deprecated}}
+  std::char_traits<unsigned long> t3; // expected-warning{{'char_traits<unsigned long>' is deprecated}}
+  (void)t1;
+  (void)t2;
+  (void)t3;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -22,37 +22,27 @@
 #include "type_algorithms.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::size_type pos)
-{
-    const S& cs = s;
-    if (pos < s.size())
-    {
-        assert(s.at(pos) == s[pos]);
-        assert(cs.at(pos) == cs[pos]);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type pos) {
+  const S& cs = s;
+  if (pos < s.size()) {
+    assert(s.at(pos) == s[pos]);
+    assert(cs.at(pos) == cs[pos]);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            TEST_IGNORE_NODISCARD s.at(pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos >= s.size());
-        }
-        try
-        {
-            TEST_IGNORE_NODISCARD cs.at(pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos >= s.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      TEST_IGNORE_NODISCARD s.at(pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos >= s.size());
     }
+    try {
+      TEST_IGNORE_NODISCARD cs.at(pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos >= s.size());
+    }
+  }
 #endif
 }
 
@@ -81,8 +71,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
@@ -18,18 +18,16 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s.back()), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs.back()), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s.back());
-    LIBCPP_ASSERT_NOEXCEPT(   cs.back());
-    assert(&cs.back() == &cs[cs.size()-1]);
-    assert(&s.back() == &s[cs.size()-1]);
-    s.back() = typename S::value_type('z');
-    assert(s.back() == typename S::value_type('z'));
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  ASSERT_SAME_TYPE(decltype(s.back()), typename S::reference);
+  ASSERT_SAME_TYPE(decltype(cs.back()), typename S::const_reference);
+  LIBCPP_ASSERT_NOEXCEPT(s.back());
+  LIBCPP_ASSERT_NOEXCEPT(cs.back());
+  assert(&cs.back() == &cs[cs.size() - 1]);
+  assert(&s.back() == &s[cs.size() - 1]);
+  s.back() = typename S::value_type('z');
+  assert(s.back() == typename S::value_type('z'));
 }
 
 template <class S>
@@ -41,14 +39,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
@@ -18,18 +18,16 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s.front()), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs.front()), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s.front());
-    LIBCPP_ASSERT_NOEXCEPT(   cs.front());
-    assert(&cs.front() == &cs[0]);
-    assert(&s.front() == &s[0]);
-    s.front() = typename S::value_type('z');
-    assert(s.front() == typename S::value_type('z'));
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  ASSERT_SAME_TYPE(decltype(s.front()), typename S::reference);
+  ASSERT_SAME_TYPE(decltype(cs.front()), typename S::const_reference);
+  LIBCPP_ASSERT_NOEXCEPT(s.front());
+  LIBCPP_ASSERT_NOEXCEPT(cs.front());
+  assert(&cs.front() == &cs[0]);
+  assert(&s.front() == &s[0]);
+  s.front() = typename S::value_type('z');
+  assert(s.front() == typename S::value_type('z'));
 }
 
 template <class S>
@@ -41,14 +39,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
@@ -38,14 +38,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
@@ -19,53 +19,53 @@
 #include "test_macros.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, test_allocator_statistics& alloc_stats)
-{
-    alloc_stats.throw_after = 0;
+TEST_CONSTEXPR_CXX20 void test(S s, test_allocator_statistics& alloc_stats) {
+  alloc_stats.throw_after = 0;
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    try
+  try
 #endif
-    {
-        while (s.size() < s.capacity())
-            s.push_back(typename S::value_type());
-        assert(s.size() == s.capacity());
-    }
+  {
+    while (s.size() < s.capacity())
+      s.push_back(typename S::value_type());
+    assert(s.size() == s.capacity());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    catch (...)
-    {
-        assert(false);
-    }
+  catch (...) {
+    assert(false);
+  }
 #endif
-    alloc_stats.throw_after = INT_MAX;
+  alloc_stats.throw_after = INT_MAX;
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s;
+  assert(s.capacity() > 0);
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >() {
+  using S = std::basic_string<char, std::char_traits<char>, test_allocator<char> >;
+  test_allocator_statistics alloc_stats;
+  S s((test_allocator<char>(&alloc_stats)));
+  test(s, alloc_stats);
+  s.assign(10, 'a');
+  s.erase(5);
+  test(s, alloc_stats);
+  s.assign(100, 'a');
+  s.erase(50);
+  test(s, alloc_stats);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    test_allocator_statistics alloc_stats;
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
-    S s((test_allocator<char>(&alloc_stats)));
-    test(s, alloc_stats);
-    s.assign(10, 'a');
-    s.erase(5);
-    test(s, alloc_stats);
-    s.assign(100, 'a');
-    s.erase(50);
-    test(s, alloc_stats);
-  }
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s;
-    assert(s.capacity() > 0);
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
@@ -17,11 +17,9 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    s.clear();
-    assert(s.size() == 0);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  s.clear();
+  assert(s.size() == 0);
 }
 
 template <class S>
@@ -41,14 +39,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -17,11 +17,9 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    ASSERT_NOEXCEPT(s.empty());
-    assert(s.empty() == (s.size() == 0));
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  ASSERT_NOEXCEPT(s.empty());
+  assert(s.empty() == (s.size() == 0));
 }
 
 template <class S>
@@ -34,14 +32,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
@@ -17,10 +17,8 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    assert(s.length() == s.size());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  assert(s.length() == s.size());
 }
 
 template <class S>
@@ -33,14 +31,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
@@ -26,34 +26,34 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test1(const S& s)
-{
-    S s2(s);
-    const size_t sz = s2.max_size() - 1;
-    try { s2.resize(sz, 'x'); }
-    catch ( const std::bad_alloc & ) { return ; }
-    assert ( s2.size() ==  sz );
+TEST_CONSTEXPR_CXX20 void test1(const S& s) {
+  S s2(s);
+  const size_t sz = s2.max_size() - 1;
+  try {
+    s2.resize(sz, 'x');
+  } catch (const std::bad_alloc&) {
+    return;
+  }
+  assert(s2.size() == sz);
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test2(const S& s)
-{
-    S s2(s);
-    const size_t sz = s2.max_size();
-    try { s2.resize(sz, 'x'); }
-    catch ( const std::bad_alloc & ) { return ; }
-    assert ( s.size() ==  sz );
+TEST_CONSTEXPR_CXX20 void test2(const S& s) {
+  S s2(s);
+  const size_t sz = s2.max_size();
+  try {
+    s2.resize(sz, 'x');
+  } catch (const std::bad_alloc&) {
+    return;
+  }
+  assert(s.size() == sz);
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    assert(s.max_size() >= s.size());
-    test1(s);
-    test2(s);
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  assert(s.max_size() >= s.size());
+  test1(s);
+  test2(s);
 }
 
 template <class S>
@@ -63,28 +63,33 @@
   test(S("12345678901234567890123456789012345678901234567890"));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
+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>>>();
+  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;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string_constexpr() {
+  S str;
 
   size_t size = str.max_size();
   assert(size > 0);
+}
+
+TEST_CONSTEXPR_CXX20 bool test_constexpr() {
+  test_string_constexpr<std::string>();
 
   return true;
 }
 #endif
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   test_constexpr();
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
@@ -26,15 +26,16 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-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 );
+TEST_CONSTEXPR_CXX20 void 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);
 }
 
 template <class S>
@@ -47,14 +48,13 @@
 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
@@ -20,21 +20,19 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(typename S::size_type min_cap, typename S::size_type erased_index)
-{
-    S s(min_cap, 'a');
-    s.erase(erased_index);
-    assert(s.size() == erased_index);
-    assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
-
-    typename S::size_type old_cap = s.capacity();
-    S s0 = s;
-    s.reserve();
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == s0);
-    assert(s.capacity() <= old_cap);
-    assert(s.capacity() >= s.size());
+void test(typename S::size_type min_cap, typename S::size_type erased_index) {
+  S s(min_cap, 'a');
+  s.erase(erased_index);
+  assert(s.size() == erased_index);
+  assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
+
+  typename S::size_type old_cap = s.capacity();
+  S s0                          = s;
+  s.reserve();
+  LIBCPP_ASSERT(s.__invariants());
+  assert(s == s0);
+  assert(s.capacity() <= old_cap);
+  assert(s.capacity() >= s.size());
 }
 
 template <class S>
@@ -47,14 +45,13 @@
 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp
@@ -23,42 +23,36 @@
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
-test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg)
-{
-    S s(min_cap, 'a');
-    s.erase(erased_index);
-    assert(s.size() == erased_index);
-    assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
+test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg) {
+  S s(min_cap, 'a');
+  s.erase(erased_index);
+  assert(s.size() == erased_index);
+  assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
 
 #if TEST_STD_VER > 17
-    typename S::size_type old_cap = s.capacity();
+  typename S::size_type old_cap = s.capacity();
 #endif
-    S s0 = s;
-    if (res_arg <= s.max_size())
-    {
-        s.reserve(res_arg);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == s0);
-        assert(s.capacity() >= res_arg);
-        assert(s.capacity() >= s.size());
+  S s0 = s;
+  if (res_arg <= s.max_size()) {
+    s.reserve(res_arg);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == s0);
+    assert(s.capacity() >= res_arg);
+    assert(s.capacity() >= s.size());
 #if TEST_STD_VER > 17
-        assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
+    assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
 #endif
-    }
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.reserve(res_arg);
-            LIBCPP_ASSERT(s.__invariants());
-            assert(false);
-        }
-        catch (std::length_error&)
-        {
-            assert(res_arg > s.max_size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      s.reserve(res_arg);
+      LIBCPP_ASSERT(s.__invariants());
+      assert(false);
+    } catch (std::length_error&) {
+      assert(res_arg > s.max_size());
     }
+  }
 #endif
 }
 
@@ -82,14 +76,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp
@@ -49,7 +49,7 @@
     LIBCPP_ASSERT(s.begin().base() == p);
     assert(std::all_of(p, p + n, [](auto ch) { return ch == 'a'; }));
     p[n - 1] = 'b';
-    p[n] = 'c'; // will be overwritten
+    p[n]     = 'c'; // will be overwritten
     return n;
   });
   const S expected = S(N - 1, 'a') + S(1, 'b');
@@ -57,9 +57,9 @@
   assert(s.c_str()[N] == '\0');
 }
 
-template <class CharT>
-constexpr bool test() {
-  using S = std::basic_string<CharT>;
+template <class CharT, template <class> class Alloc>
+constexpr bool test_string() {
+  using S = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
   test_appending<S>(10, 15, 15);
   test_appending<S>(10, 15, 20);
   test_appending<S>(10, 40, 40);
@@ -85,19 +85,26 @@
 }
 
 int main(int, char**) {
-  test<char>();
-  test<char8_t>();
-  test<char16_t>();
-  test<char32_t>();
+  test_string<char, std::allocator>();
+
+  test_string<char8_t, std::allocator>();
+
+  test_string<char16_t, std::allocator>();
+
+  test_string<char32_t, std::allocator>();
 
-  static_assert(test<char>());
-  static_assert(test<char8_t>());
-  static_assert(test<char16_t>());
-  static_assert(test<char32_t>());
+  static_assert(test_string<char, std::allocator>());
+
+  static_assert(test_string<char8_t, std::allocator>());
+
+  static_assert(test_string<char16_t, std::allocator>());
+
+  static_assert(test_string<char32_t, std::allocator>());
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-  static_assert(test<wchar_t>());
+  test_string<wchar_t, std::allocator>();
+
+  static_assert(test_string<wchar_t, std::allocator>());
 #endif
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
@@ -18,28 +18,21 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::size_type n, S expected)
-{
-    if (n <= s.max_size())
-    {
-        s.resize(n);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type n, S expected) {
+  if (n <= s.max_size()) {
+    s.resize(n);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.resize(n);
-            assert(false);
-        }
-        catch (std::length_error&)
-        {
-            assert(n > s.max_size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      s.resize(n);
+      assert(false);
+    } catch (std::length_error&) {
+      assert(n > s.max_size());
     }
+  }
 #endif
 }
 
@@ -65,15 +58,15 @@
 
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
@@ -18,28 +18,21 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::size_type n, typename S::value_type c, S expected)
-{
-    if (n <= s.max_size())
-    {
-        s.resize(n, c);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type n, typename S::value_type c, S expected) {
+  if (n <= s.max_size()) {
+    s.resize(n, c);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.resize(n, c);
-            assert(false);
-        }
-        catch (std::length_error&)
-        {
-            assert(n > s.max_size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      s.resize(n, c);
+      assert(false);
+    } catch (std::length_error&) {
+      assert(n > s.max_size());
     }
+  }
 #endif
 }
 
@@ -66,14 +59,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
@@ -17,16 +17,14 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    typename S::size_type old_cap = s.capacity();
-    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 void test(S s) {
+  typename S::size_type old_cap = s.capacity();
+  S s0                          = s;
+  s.shrink_to_fit();
+  LIBCPP_ASSERT(s.__invariants());
+  assert(s == s0);
+  assert(s.capacity() <= old_cap);
+  assert(s.capacity() >= s.size());
 }
 
 template <class S>
@@ -46,14 +44,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
@@ -17,10 +17,8 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s, typename S::size_type c)
-{
-    assert(s.size() == c);
+TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::size_type c) {
+  assert(s.size() == c);
 }
 
 template <class S>
@@ -33,14 +31,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
@@ -25,168 +25,159 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(SV sv, std::size_t pos, std::size_t n)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    typedef typename S::size_type Size;
-    if (pos <= sv.size())
-    {
-        S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
-        LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= sv.size());
-        std::size_t rlen = std::min(sv.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(SV sv, std::size_t pos, std::size_t n) {
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  typedef typename S::size_type Size;
+  if (pos <= sv.size()) {
+    S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
+    LIBCPP_ASSERT(s2.__invariants());
+    assert(pos <= sv.size());
+    std::size_t rlen = std::min(sv.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == A());
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > sv.size());
     }
+  }
 #endif
 }
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::size_type Size;
-    if (pos <= sv.size())
-    {
-        S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
-        LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= sv.size());
-        std::size_t rlen = std::min(sv.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == a);
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a) {
+  typedef typename S::traits_type T;
+  typedef typename S::size_type Size;
+  if (pos <= sv.size()) {
+    S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
+    LIBCPP_ASSERT(s2.__invariants());
+    assert(pos <= sv.size());
+    std::size_t rlen = std::min(sv.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == a);
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > sv.size());
     }
+  }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string_view<char, std::char_traits<char> > SV;
-    typedef std::basic_string     <char, std::char_traits<char>, A> S;
-
-    test<S,SV>(SV(), 0, 0);
-    test<S,SV>(SV(), 0, 1);
-    test<S,SV>(SV(), 1, 0);
-    test<S,SV>(SV(), 1, 1);
-    test<S,SV>(SV(), 1, 2);
-    test<S,SV>(SV("1"), 0, 0);
-    test<S,SV>(SV("1"), 0, 1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   0);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,  10);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100);
-
-    test<S,SV>(SV(), 0, 0, A(4));
-    test<S,SV>(SV(), 0, 1, A(4));
-    test<S,SV>(SV(), 1, 0, A(4));
-    test<S,SV>(SV(), 1, 1, A(4));
-    test<S,SV>(SV(), 1, 2, A(4));
-    test<S,SV>(SV("1"), 0, 0, A(6));
-    test<S,SV>(SV("1"), 0, 1, A(6));
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   0, A(8));
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   1, A(8));
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,  10, A(8));
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A(8));
-  }
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A  = Alloc<CharT>;
+  using S  = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  using SV = std::basic_string_view< CharT, std::char_traits<CharT> >;
+
+  test<S, SV>(SV(), 0, 0);
+  test<S, SV>(SV(), 0, 1);
+  test<S, SV>(SV(), 1, 0);
+  test<S, SV>(SV(), 1, 1);
+  test<S, SV>(SV(), 1, 2);
+  test<S, SV>(SV("1"), 0, 0);
+  test<S, SV>(SV("1"), 0, 1);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100);
+
+  test<S, SV>(SV(), 0, 0, A());
+  test<S, SV>(SV(), 0, 1, A());
+  test<S, SV>(SV(), 1, 0, A());
+  test<S, SV>(SV(), 1, 1, A());
+  test<S, SV>(SV(), 1, 2, A());
+  test<S, SV>(SV("1"), 0, 0, A());
+  test<S, SV>(SV("1"), 0, 1, A());
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0, A());
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1, A());
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10, A());
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A  = test_allocator<char>;
+  using S  = std::basic_string<char, std::char_traits<char>, A>;
+  using SV = std::basic_string_view< char, std::char_traits<char> >;
+
+  test<S, SV>(SV(), 0, 0);
+  test<S, SV>(SV(), 0, 1);
+  test<S, SV>(SV(), 1, 0);
+  test<S, SV>(SV(), 1, 1);
+  test<S, SV>(SV(), 1, 2);
+  test<S, SV>(SV("1"), 0, 0);
+  test<S, SV>(SV("1"), 0, 1);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10);
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100);
+
+  test<S, SV>(SV(), 0, 0, A(4));
+  test<S, SV>(SV(), 0, 1, A(4));
+  test<S, SV>(SV(), 1, 0, A(4));
+  test<S, SV>(SV(), 1, 1, A(4));
+  test<S, SV>(SV(), 1, 2, A(4));
+  test<S, SV>(SV("1"), 0, 0, A(6));
+  test<S, SV>(SV("1"), 0, 1, A(6));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0, A(8));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1, A(8));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10, A(8));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A(8));
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string_view<char, std::char_traits<char> > SV;
-    typedef std::basic_string     <char, std::char_traits<char>, A> S;
-
-    test<S,SV>(SV(), 0, 0);
-    test<S,SV>(SV(), 0, 1);
-    test<S,SV>(SV(), 1, 0);
-    test<S,SV>(SV(), 1, 1);
-    test<S,SV>(SV(), 1, 2);
-    test<S,SV>(SV("1"), 0, 0);
-    test<S,SV>(SV("1"), 0, 1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100);
-
-    test<S,SV>(SV(), 0, 0, A());
-    test<S,SV>(SV(), 0, 1, A());
-    test<S,SV>(SV(), 1, 0, A());
-    test<S,SV>(SV(), 1, 1, A());
-    test<S,SV>(SV(), 1, 2, A());
-    test<S,SV>(SV("1"), 0, 0, A());
-    test<S,SV>(SV("1"), 0, 1, A());
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0, A());
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1, A());
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10, A());
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, A());
-  }
+  test_string<char, min_allocator>();
 #endif
   {
-    typedef std::string S;
-    typedef std::string_view SV;
-    S s = "ABCD";
-    SV sv = "EFGH";
+    using S    = std::string;
+    using SV   = std::string_view;
+    S s        = "ABCD";
+    SV sv      = "EFGH";
     char arr[] = "IJKL";
 
-    S s1("CDEF", 4);    // calls ctor(const char *, len)
+    S s1("CDEF", 4); // calls ctor(const char *, len)
     assert(s1 == "CDEF");
 
     S s2("QRST", 0, 3); // calls ctor(string("QRST", pos, len)
     assert(s2 == "QRS");
 
-    S s3(sv, 0, std::string::npos);   // calls ctor(T, pos, npos)
+    S s3(sv, 0, std::string::npos); // calls ctor(T, pos, npos)
     assert(s3 == sv);
 
-    S s4(sv, 0, 3);   // calls ctor(T, pos, len)
+    S s4(sv, 0, 3); // calls ctor(T, pos, len)
     assert(s4 == "EFG");
 
-    S s5(arr, 0, 2);     // calls ctor(const char *, len)
+    S s5(arr, 0, 2); // calls ctor(const char *, len)
     assert(s5 == "IJ");
 
-    S s6(arr, 0);     // calls ctor(const char *, len)
+    S s6(arr, 0); // calls ctor(const char *, len)
     assert(s6 == "");
 
-    S s7(s.data(), 2);     // calls ctor(const char *, len)
+    S s7(s.data(), 2); // calls ctor(const char *, len)
     assert(s7 == "AB");
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
@@ -17,15 +17,13 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-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 void 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());
 }
 
 template <class S>
@@ -39,14 +37,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
@@ -18,39 +18,43 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s1)
-{
-    S s2 = s1;
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == s1.get_allocator());
+TEST_CONSTEXPR_CXX20 void test(S s1) {
+  S s2 = s1;
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == s1.get_allocator());
+}
+
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(A()));
+  test(S("1", A()));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+  test(S(A(3)));
+  test(S("1", A(5)));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(A(3)));
-    test(S("1", A(5)));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-  }
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(A{}));
-    test(S("1", A()));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-  }
+  test_string<char, min_allocator>();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -19,98 +19,101 @@
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct alloc_imp {
-    bool active;
-
-    TEST_CONSTEXPR alloc_imp() : active(true) {}
-
-    template <class T>
-    T* allocate(std::size_t n)
-    {
-        if (active)
-            return static_cast<T*>(std::malloc(n * sizeof(T)));
-        else
-            throw std::bad_alloc();
-    }
-
-    template <class T>
-    void deallocate(T* p, std::size_t) { std::free(p); }
-    void activate  ()                  { active = true; }
-    void deactivate()                  { active = false; }
+  bool active;
+
+  TEST_CONSTEXPR alloc_imp() : active(true) {}
+
+  template <class T>
+  T* allocate(std::size_t n) {
+    if (active)
+      return static_cast<T*>(std::malloc(n * sizeof(T)));
+    else
+      throw std::bad_alloc();
+  }
+
+  template <class T>
+  void deallocate(T* p, std::size_t) {
+    std::free(p);
+  }
+  void activate() { active = true; }
+  void deactivate() { active = false; }
 };
 
 template <class T>
 struct poca_alloc {
-    typedef T value_type;
-    typedef std::true_type propagate_on_container_copy_assignment;
+  typedef T value_type;
+  typedef std::true_type propagate_on_container_copy_assignment;
 
-    alloc_imp *imp;
+  alloc_imp* imp;
 
-    TEST_CONSTEXPR poca_alloc(alloc_imp *imp_) : imp (imp_) {}
+  TEST_CONSTEXPR poca_alloc(alloc_imp* imp_) : imp(imp_) {}
 
-    template <class U>
-    TEST_CONSTEXPR poca_alloc(const poca_alloc<U>& other) : imp(other.imp) {}
+  template <class U>
+  TEST_CONSTEXPR poca_alloc(const poca_alloc<U>& other) : imp(other.imp) {}
 
-    T*   allocate  (std::size_t n)       { return imp->allocate<T>(n);}
-    void deallocate(T* p, std::size_t n) { imp->deallocate(p, n); }
+  T* allocate(std::size_t n) { return imp->allocate<T>(n); }
+  void deallocate(T* p, std::size_t n) { imp->deallocate(p, n); }
 };
 
 template <typename T, typename U>
-bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
-{
-    return lhs.imp == rhs.imp;
+bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs) {
+  return lhs.imp == rhs.imp;
 }
 
 template <typename T, typename U>
-bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
-{
-    return lhs.imp != rhs.imp;
+bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs) {
+  return lhs.imp != rhs.imp;
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test_assign(S &s1, const S& s2)
-{
-    try { s1 = s2; }
-    catch ( std::bad_alloc &) { return; }
-    assert(false);
+TEST_CONSTEXPR_CXX20 void test_assign(S& s1, const S& s2) {
+  try {
+    s1 = s2;
+  } catch (std::bad_alloc&) {
+    return;
+  }
+  assert(false);
 }
 #endif
 
+template <class S>
+TEST_CONSTEXPR_CXX20 void test(S s1, const typename S::allocator_type& a) {
+  S s2(s1, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == a);
+}
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(), A());
+  test(S("1"), A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
+}
 
-template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s1, const typename S::allocator_type& a)
-{
-    S s2(s1, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == a);
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+  test(S(), A(3));
+  test(S("1"), A(5));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(), A(3));
-    test(S("1"), A(5));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
-  }
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(), A());
-    test(S("1"), A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-  }
+  test_string<char, min_allocator>();
 
-#ifndef TEST_HAS_NO_EXCEPTIONS
+#  ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
-    const char * p1 = "This is my first string";
-    const char * p2 = "This is my second string";
+    const char* p1 = "This is my first string";
+    const char* p2 = "This is my second string";
 
     alloc_imp imp1;
     alloc_imp imp2;
@@ -125,14 +128,13 @@
     assert(s1 == p1);
     assert(s2 == p2);
   }
-#endif
+#  endif
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/default.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/default.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/default.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/default.pass.cpp
@@ -20,9 +20,11 @@
 // Test the noexcept specification, which is a conforming extension
 LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<std::string>::value, "");
 LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<
-                     std::basic_string<char, std::char_traits<char>, test_allocator<char>>>::value, "");
+                         std::basic_string<char, std::char_traits<char>, test_allocator<char> > >::value,
+                     "");
 LIBCPP_STATIC_ASSERT(!std::is_nothrow_default_constructible<
-                     std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10>>>::value, "");
+                         std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10> > >::value,
+                     "");
 #endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
diff --git a/libcxx/test/std/strings/basic.string/string.cons/dtor.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/dtor.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/dtor.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/dtor.pass.cpp
@@ -35,15 +35,15 @@
 #endif
 
 static_assert(std::is_nothrow_destructible<std::string>::value, "");
-static_assert(std::is_nothrow_destructible<
-                std::basic_string<char, std::char_traits<char>, test_allocator<char>>>::value, "");
-LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<
-                     std::basic_string<char, std::char_traits<char>, throwing_alloc<char>>>::value, "");
+static_assert(
+    std::is_nothrow_destructible< std::basic_string<char, std::char_traits<char>, test_allocator<char> > >::value, "");
+LIBCPP_STATIC_ASSERT(
+    !std::is_nothrow_destructible< std::basic_string<char, std::char_traits<char>, throwing_alloc<char> > >::value, "");
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_allocator_statistics alloc_stats;
   {
-    std::basic_string<char, std::char_traits<char>, test_allocator<char>> str2((test_allocator<char>(&alloc_stats)));
+    std::basic_string<char, std::char_traits<char>, test_allocator<char> > str2((test_allocator<char>(&alloc_stats)));
     str2 = "long long string so no SSO";
     assert(alloc_stats.alloc_count == 1);
   }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
@@ -19,37 +19,28 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s = {'a', 'b', 'c'};
-    assert(s == "abc");
-  }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  {
-    std::wstring s;
-    s = {L'a', L'b', L'c'};
-    assert(s == L"abc");
-  }
-#endif
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s = {'a', 'b', 'c'};
-    assert(s == "abc");
-  }
+template <template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void
+test_string(){{std::basic_string<char, std::char_traits<char>, Alloc<char> > s = {'a', 'b', 'c'};
+assert(s == "abc");
+}
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  {
-    typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-    S s;
-    s = {L'a', L'b', L'c'};
-    assert(s == L"abc");
-  }
+{
+  std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> > s;
+  s = {L'a', L'b', L'c'};
+  assert(s == L"abc");
+}
 #endif
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::allocator>();
+  test_string<min_allocator>();
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
@@ -18,24 +18,21 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_case() {
+  S s;
+  s = {'a', 'b', 'c'};
+  assert(s == "abc");
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s;
-    s = {'a', 'b', 'c'};
-    assert(s == "abc");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s;
-    s = {'a', 'b', 'c'};
-    assert(s == "abc");
-  }
+  test_case<std::string>();
+  test_case<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -12,7 +12,6 @@
 //   basic_string(InputIterator begin, InputIterator end,
 //   const Allocator& a = Allocator()); // constexpr since C++20
 
-
 #include <string>
 #include <iterator>
 #include <cassert>
@@ -24,118 +23,83 @@
 #include "min_allocator.h"
 
 template <class It>
-TEST_CONSTEXPR_CXX20 void
-test(It first, It last)
-{
-    typedef typename std::iterator_traits<It>::value_type charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(first, last);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
-    unsigned i = 0;
-    for (It it = first; it != last;) {
-        assert(s2[i] == *it);
-        ++it;
-        ++i;
-    }
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(It first, It last) {
+  typedef typename std::iterator_traits<It>::value_type charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::allocator_type A;
+  S s2(first, last);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
+  unsigned i = 0;
+  for (It it = first; it != last;) {
+    assert(s2[i] == *it);
+    ++it;
+    ++i;
+  }
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class It, class A>
-TEST_CONSTEXPR_CXX20 void
-test(It first, It last, const A& a)
-{
-    typedef typename std::iterator_traits<It>::value_type charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(first, last, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
-    unsigned i = 0;
-    for (It it = first; it != last;) {
-        assert(s2[i] == *it);
-        ++it;
-        ++i;
-    }
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(It first, It last, const A& a) {
+  typedef typename std::iterator_traits<It>::value_type charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  S s2(first, last, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
+  unsigned i = 0;
+  for (It it = first; it != last;) {
+    assert(s2[i] == *it);
+    ++it;
+    ++i;
+  }
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    const char* s = "12345678901234567890123456789012345678901234567890";
-
-    test(s, s);
-    test(s, s, A(2));
-
-    test(s, s+1);
-    test(s, s+1, A(2));
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const Alloc& a) {
+  const char* s = "12345678901234567890123456789012345678901234567890";
 
-    test(s, s+10);
-    test(s, s+10, A(2));
+  test(s, s);
+  test(s, s, a);
 
-    test(s, s+50);
-    test(s, s+50, A(2));
+  test(s, s + 1);
+  test(s, s + 1, a);
 
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), A(2));
+  test(s, s + 10);
+  test(s, s + 10, a);
 
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A(2));
+  test(s, s + 50);
+  test(s, s + 50, a);
 
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A(2));
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), a);
 
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A(2));
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    const char* s = "12345678901234567890123456789012345678901234567890";
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1));
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1), a);
 
-    test(s, s);
-    test(s, s, A());
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 10));
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 10), a);
 
-    test(s, s+1);
-    test(s, s+1, A());
-
-    test(s, s+10);
-    test(s, s+10, A());
-
-    test(s, s+50);
-    test(s, s+50, A());
-
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), A());
-
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A());
-
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A());
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 50));
+  test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 50), a);
+}
 
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
-    test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A());
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test<test_allocator<char> >(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test<min_allocator<char> >(min_allocator<char>());
 #endif
   {
-      static_assert((!std::is_constructible<std::string, std::string,
-                                            std::string>::value),
-                    "");
-      static_assert(
-          (!std::is_constructible<std::string, std::string, std::string,
-                                  std::allocator<char> >::value),
-          "");
+    static_assert((!std::is_constructible<std::string, std::string, std::string>::value), "");
+    static_assert((!std::is_constructible<std::string, std::string, std::string, std::allocator<char> >::value), "");
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
@@ -31,18 +31,21 @@
 #include "min_allocator.h"
 
 class NotAnIterator {};
-using NotAnInputIterator = std::back_insert_iterator<std::basic_string<char16_t>>;
+using NotAnInputIterator = std::back_insert_iterator<std::basic_string<char16_t> >;
 
 template <typename T>
-struct NotAnAllocator { typedef T value_type; };
+struct NotAnAllocator {
+  typedef T value_type;
+};
 
 template <class Iter, class Alloc, class = void>
-struct CanDeduce : std::false_type { };
+struct CanDeduce : std::false_type {};
 
 template <class Iter, class Alloc>
-struct CanDeduce<Iter, Alloc, decltype((void)
-  std::basic_string{std::declval<Iter>(), std::declval<Iter>(), std::declval<Alloc>()}
-)> : std::true_type { };
+struct CanDeduce<Iter,
+                 Alloc,
+                 decltype((void)std::basic_string{std::declval<Iter>(), std::declval<Iter>(), std::declval<Alloc>()})>
+    : std::true_type {};
 
 static_assert( CanDeduce<char*, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnIterator, std::allocator<char>>::value);
@@ -52,65 +55,50 @@
 static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t>>::value);
 #endif
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void
+test_string(const CharT* s, const std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> > s1) {
+  using S = decltype(s1); // what type did we get?
+  static_assert(std::is_same_v<typename S::value_type, CharT>, "");
+  static_assert(std::is_same_v<typename S::traits_type, std::char_traits<CharT> >, "");
+  static_assert(std::is_same_v<typename S::allocator_type, Alloc<CharT> >, "");
+  assert(s1.size() == 10);
+  assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     const char* s = "12345678901234";
-    std::basic_string s1(s, s+10);  // Can't use {} here
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1(s, s + 10); // Can't use {} here
+    test_string<char, std::allocator>(s, std::move(s1));
   }
   {
     const char* s = "12345678901234";
-    std::basic_string s1{s, s+10, std::allocator<char>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + 10, std::allocator<char>{}};
+    test_string<char, std::allocator>(s, std::move(s1));
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     const wchar_t* s = L"12345678901234";
-    std::basic_string s1{s, s+10, test_allocator<wchar_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + 10, test_allocator<wchar_t>{}};
+    test_string<wchar_t, test_allocator>(s, std::move(s1));
   }
-#endif
   {
     const char16_t* s = u"12345678901234";
-    std::basic_string s1{s, s+10, min_allocator<char16_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + 10, min_allocator<char16_t>{}};
+    test_string<char16_t, min_allocator>(s, std::move(s1));
   }
+#endif
   {
     const char32_t* s = U"12345678901234";
-    std::basic_string s1{s, s+10, explicit_allocator<char32_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + 10, explicit_allocator<char32_t>{}};
+    test_string<char32_t, explicit_allocator>(s, std::move(s1));
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp
@@ -20,39 +20,42 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s0)
-{
-    S s1 = s0;
-    S s2 = std::move(s0);
-    LIBCPP_ASSERT(s2.__invariants());
-    LIBCPP_ASSERT(s0.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == s1.get_allocator());
+TEST_CONSTEXPR_CXX20 void test(S s0) {
+  S s1 = s0;
+  S s2 = std::move(s0);
+  LIBCPP_ASSERT(s2.__invariants());
+  LIBCPP_ASSERT(s0.__invariants());
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == s1.get_allocator());
+}
+
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  typedef Alloc<CharT> A;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(A{}));
+  test(S("1", A()));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+  test(S(A(3)));
+  test(S("1", A(5)));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(A(3)));
-    test(S("1", A(5)));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-  }
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(A{}));
-    test(S("1", A()));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-  }
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -20,64 +20,67 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s0, const typename S::allocator_type& a)
-{
-    S s1 = s0;
-    S s2(std::move(s0), a);
-    LIBCPP_ASSERT(s2.__invariants());
-    LIBCPP_ASSERT(s0.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == a);
+TEST_CONSTEXPR_CXX20 void test(S s0, const typename S::allocator_type& a) {
+  S s1 = s0;
+  S s2(std::move(s0), a);
+  LIBCPP_ASSERT(s2.__invariants());
+  LIBCPP_ASSERT(s0.__invariants());
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == a);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+#if TEST_STD_VER > 14
+  static_assert((noexcept(S{})), "");
+#elif TEST_STD_VER >= 11
+  static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "");
+#endif
+  test(S(), A());
+  test(S("1"), A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   test_allocator_statistics alloc_stats;
+  typedef test_allocator<char> A;
+  typedef std::basic_string<char, std::char_traits<char>, A> S;
   {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
-    static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "");
 #elif TEST_STD_VER >= 11
-    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "");
 #endif
     test(S(), A(3, &alloc_stats));
     test(S("1"), A(5, &alloc_stats));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7, &alloc_stats));
   }
 
-    int alloc_count = alloc_stats.alloc_count;
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-#if TEST_STD_VER > 14
-    static_assert((noexcept(S{})), "" );
-#elif TEST_STD_VER >= 11
-    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
-#endif
-    S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe", A(&alloc_stats));
-    S s2 (std::move(s1), A(1, &alloc_stats));
-  }
-    assert ( alloc_stats.alloc_count == alloc_count );
+  int alloc_count = alloc_stats.alloc_count;
   {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
-    static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "");
 #elif TEST_STD_VER >= 11
-    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "");
 #endif
-    test(S(), A());
-    test(S("1"), A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
+    S s1("Twas brillig, and the slivy toves did gyre and gymbal in the wabe", A(&alloc_stats));
+    S s2(std::move(s1), A(1, &alloc_stats));
   }
+  assert(alloc_stats.alloc_count == alloc_count);
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, test_allocator>();
+  test_string<char, min_allocator>();
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
@@ -27,39 +27,36 @@
 #include "test_allocator.h"
 
 template <class T>
-struct some_alloc
-{
-    typedef T value_type;
-    some_alloc(const some_alloc&);
-    T *allocate(size_t);
+struct some_alloc {
+  typedef T value_type;
+  some_alloc(const some_alloc&);
+  T* allocate(size_t);
 };
 
 template <class T>
-struct some_alloc2
-{
-    typedef T value_type;
+struct some_alloc2 {
+  typedef T value_type;
 
-    some_alloc2() {}
-    some_alloc2(const some_alloc2&);
-    T *allocate(size_t);
-    void deallocate(void*, unsigned) {}
+  some_alloc2() {}
+  some_alloc2(const some_alloc2&);
+  T* allocate(size_t);
+  void deallocate(void*, unsigned) {}
 
-    typedef std::false_type propagate_on_container_move_assignment;
-    typedef std::true_type is_always_equal;
+  typedef std::false_type propagate_on_container_move_assignment;
+  typedef std::true_type is_always_equal;
 };
 
 template <class T>
-struct some_alloc3
-{
-    typedef T value_type;
+struct some_alloc3 {
+  typedef T value_type;
 
-    some_alloc3() {}
-    some_alloc3(const some_alloc3&);
-    T *allocate(size_t);
-    void deallocate(void*, unsigned) {}
+  some_alloc3() {}
+  some_alloc3(const some_alloc3&);
+  T* allocate(size_t);
+  void deallocate(void*, unsigned) {}
 
-    typedef std::false_type propagate_on_container_move_assignment;
-    typedef std::false_type is_always_equal;
+  typedef std::false_type propagate_on_container_move_assignment;
+  typedef std::false_type is_always_equal;
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
@@ -68,27 +65,27 @@
     static_assert(std::is_nothrow_move_assignable<C>::value, "");
   }
   {
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
+    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > C;
     static_assert(!std::is_nothrow_move_assignable<C>::value, "");
   }
   {
-    typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc<char> > C;
 #if TEST_STD_VER > 14
     // if the allocators are always equal, then the move assignment can be noexcept
-    static_assert( std::is_nothrow_move_assignable<C>::value, "");
+    static_assert(std::is_nothrow_move_assignable<C>::value, "");
 #else
-      static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+    static_assert(!std::is_nothrow_move_assignable<C>::value, "");
 #endif
   }
 #if TEST_STD_VER > 14
   {
     //  POCMA is false, always equal
-    typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
-    static_assert( std::is_nothrow_move_assignable<C>::value, "");
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char> > C;
+    static_assert(std::is_nothrow_move_assignable<C>::value, "");
   }
   {
     //  POCMA is false, not always equal
-    typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char>> C;
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char> > C;
     static_assert(!std::is_nothrow_move_assignable<C>::value, "");
   }
 #endif
@@ -96,8 +93,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
@@ -21,15 +21,13 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s1, S s2)
-{
-    S s0 = s2;
-    s1 = std::move(s2);
-    LIBCPP_ASSERT(s1.__invariants());
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s1 == s0);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, S s2) {
+  S s0 = s2;
+  s1   = std::move(s2);
+  LIBCPP_ASSERT(s1.__invariants());
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s1 == s0);
+  assert(s1.capacity() >= s1.size());
 }
 
 template <class S>
@@ -54,14 +52,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
@@ -21,24 +21,23 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::string C;
-        static_assert(std::is_nothrow_move_constructible<C>::value, "");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
-        static_assert(std::is_nothrow_move_constructible<C>::value, "");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10>> C;
+int main(int, char**) {
+  {
+    typedef std::string C;
+    static_assert(std::is_nothrow_move_constructible<C>::value, "");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > C;
+    static_assert(std::is_nothrow_move_constructible<C>::value, "");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10> > C;
 #if TEST_STD_VER <= 14
-        static_assert(!std::is_nothrow_move_constructible<C>::value, "");
+    static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #else
-        static_assert( std::is_nothrow_move_constructible<C>::value, "");
+    static_assert(std::is_nothrow_move_constructible<C>::value, "");
 #endif
-    }
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -21,75 +21,57 @@
 #include "min_allocator.h"
 
 template <class charT>
-TEST_CONSTEXPR_CXX20 void
-test(const charT* s)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    std::size_t n = T::length(s);
-    S s2(s);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(const charT* s) {
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  std::size_t n = T::length(s);
+  S s2(s);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
-template <class charT, class A>
-TEST_CONSTEXPR_CXX20 void
-test(const charT* s, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
-    std::size_t n = T::length(s);
-    S s2(s, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+template <class charT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const charT* s, const Alloc& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> S;
+  typedef typename S::traits_type T;
+  std::size_t n = T::length(s);
+  S s2(s, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-    {
-    typedef test_allocator<char> A;
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const Alloc& a) {
+  test("");
+  test("", a);
 
-    test("");
-    test("", A(2));
+  test("1");
+  test("1", a);
 
-    test("1");
-    test("1", A(2));
+  test("1234567980");
+  test("1234567980", a);
 
-    test("1234567980");
-    test("1234567980", A(2));
+  test("123456798012345679801234567980123456798012345679801234567980");
+  test("123456798012345679801234567980123456798012345679801234567980", a);
+}
 
-    test("123456798012345679801234567980123456798012345679801234567980");
-    test("123456798012345679801234567980123456798012345679801234567980", A(2));
-    }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test<test_allocator<char> >(test_allocator<char>(2));
 #if TEST_STD_VER >= 11
-    {
-    typedef min_allocator<char> A;
-
-    test("");
-    test("", A());
-
-    test("1");
-    test("1", A());
-
-    test("1234567980");
-    test("1234567980", A());
-
-    test("123456798012345679801234567980123456798012345679801234567980");
-    test("123456798012345679801234567980123456798012345679801234567980", A());
-    }
+  test<min_allocator<char> >(min_allocator<char>());
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
@@ -18,15 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s1, const typename S::value_type* s2)
-{
-    typedef typename S::traits_type T;
-    s1 = s2;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == T::length(s2));
-    assert(T::compare(s1.data(), s2, s1.size()) == 0);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, const typename S::value_type* s2) {
+  typedef typename S::traits_type T;
+  s1 = s2;
+  LIBCPP_ASSERT(s1.__invariants());
+  assert(s1.size() == T::length(s2));
+  assert(T::compare(s1.data(), s2, s1.size()) == 0);
+  assert(s1.capacity() >= s1.size());
 }
 
 template <class S>
@@ -37,28 +35,25 @@
   test(S("1"), "2");
   test(S("1"), "2");
 
-  test(S(),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-  test(S("123456789"),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+  test(S(), "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+  test(S("123456789"), "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+       "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-          "1234567890123456789012345678901234567890123456789012345678901234567890"),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+         "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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -19,67 +19,50 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-template <class charT>
-TEST_CONSTEXPR_CXX20 void
-test(const charT* s, unsigned n)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    S s2(s, n);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+template <class CharT>
+TEST_CONSTEXPR_CXX20 void test(const CharT* s, unsigned n) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT> > S;
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  S s2(s, n);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
-template <class charT, class A>
-TEST_CONSTEXPR_CXX20 void
-test(const charT* s, unsigned n, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
-    S s2(s, n, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+template <class CharT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const CharT* s, unsigned n, const Alloc& a) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc> S;
+  typedef typename S::traits_type T;
+  S s2(s, n, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const Alloc& a) {
+  test("", 0);
+  test("", 0, a);
 
-    test("", 0);
-    test("", 0, A(2));
+  test("1", 1);
+  test("1", 1, a);
 
-    test("1", 1);
-    test("1", 1, A(2));
+  test("1234567980", 10);
+  test("1234567980", 10, a);
 
-    test("1234567980", 10);
-    test("1234567980", 10, A(2));
+  test("123456798012345679801234567980123456798012345679801234567980", 60);
+  test("123456798012345679801234567980123456798012345679801234567980", 60, a);
+}
 
-    test("123456798012345679801234567980123456798012345679801234567980", 60);
-    test("123456798012345679801234567980123456798012345679801234567980", 60, A(2));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test<test_allocator<char> >(test_allocator<char>(2));
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-
-    test("", 0);
-    test("", 0, A());
-
-    test("1", 1);
-    test("1", 1, A());
-
-    test("1234567980", 10);
-    test("1234567980", 10, A());
-
-    test("123456798012345679801234567980123456798012345679801234567980", 60);
-    test("123456798012345679801234567980123456798012345679801234567980", 60, A());
-  }
+  test<min_allocator<char> >(min_allocator<char>());
 #endif
 
 #if TEST_STD_VER >= 11
@@ -93,8 +76,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -21,110 +21,104 @@
 #include "min_allocator.h"
 
 template <class charT>
-TEST_CONSTEXPR_CXX20 void
-test(unsigned n, charT c)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(n, c);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    for (unsigned i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(unsigned n, charT c) {
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::allocator_type A;
+  S s2(n, c);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  for (unsigned i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
-template <class charT, class A>
-TEST_CONSTEXPR_CXX20 void
-test(unsigned n, charT c, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(n, c, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    for (unsigned i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+template <class charT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(unsigned n, charT c, const Alloc& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> S;
+  S s2(n, c, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  for (unsigned i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp>
-TEST_CONSTEXPR_CXX20 void
-test(Tp n, Tp c)
-{
-    typedef char charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(n, c);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(n));
-    for (int i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c) {
+  typedef char charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::allocator_type A;
+  S s2(n, c);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(n));
+  for (int i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp, class A>
-TEST_CONSTEXPR_CXX20 void
-test(Tp n, Tp c, const A& a)
-{
-    typedef char charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(n, c, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(n));
-    for (int i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c, const A& a) {
+  typedef char charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  S s2(n, c, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(n));
+  for (int i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
+template <class A>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(0, 'a');
+  test(0, 'a', A());
 
-    test(0, 'a');
-    test(0, 'a', A(2));
+  test(1, 'a');
+  test(1, 'a', A());
 
-    test(1, 'a');
-    test(1, 'a', A(2));
+  test(10, 'a');
+  test(10, 'a', A());
 
-    test(10, 'a');
-    test(10, 'a', A(2));
+  test(100, 'a');
+  test(100, 'a', A());
 
-    test(100, 'a');
-    test(100, 'a', A(2));
+  test(static_cast<char>(100), static_cast<char>(65));
+  test(static_cast<char>(100), static_cast<char>(65), A());
+}
 
-    test(static_cast<char>(100), static_cast<char>(65));
-    test(static_cast<char>(100), static_cast<char>(65), A(3));
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<test_allocator<char> >() {
+  using A = test_allocator<char>;
+  test(0, 'a');
+  test(0, 'a', A(2));
 
-    test(0, 'a');
-    test(0, 'a', A());
+  test(1, 'a');
+  test(1, 'a', A(2));
 
-    test(1, 'a');
-    test(1, 'a', A());
+  test(10, 'a');
+  test(10, 'a', A(2));
 
-    test(10, 'a');
-    test(10, 'a', A());
+  test(100, 'a');
+  test(100, 'a', A(2));
 
-    test(100, 'a');
-    test(100, 'a', A());
+  test(static_cast<char>(100), static_cast<char>(65));
+  test(static_cast<char>(100), static_cast<char>(65), A(3));
+}
 
-    test(static_cast<char>(100), static_cast<char>(65));
-    test(static_cast<char>(100), static_cast<char>(65), A());
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<test_allocator<char> >();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator<char> >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
@@ -24,13 +24,11 @@
 static_assert(!std::is_convertible<std::string_view, std::string const&>::value, "");
 static_assert(!std::is_convertible<std::string_view, std::string>::value, "");
 
-template <class charT>
-TEST_CONSTEXPR_CXX20 void
-test(std::basic_string_view<charT> sv)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
+template <class CharT>
+TEST_CONSTEXPR_CXX20 void test(std::basic_string_view<CharT> sv) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT> > S;
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
   {
     S s2(sv);
     LIBCPP_ASSERT(s2.__invariants());
@@ -50,12 +48,10 @@
   }
 }
 
-template <class charT, class A>
-TEST_CONSTEXPR_CXX20 void
-test(std::basic_string_view<charT> sv, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
+template <class CharT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(std::basic_string_view<CharT> sv, const Alloc& a) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc> S;
+  typedef typename S::traits_type T;
   {
     S s2(sv, a);
     LIBCPP_ASSERT(s2.__invariants());
@@ -75,47 +71,33 @@
   }
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string_view<char, std::char_traits<char> > SV;
-
-    test(SV(""));
-    test(SV(""), A(2));
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  typedef std::basic_string_view<char, std::char_traits<char> > SV;
 
-    test(SV("1"));
-    test(SV("1") ,A(2));
-
-    test(SV("1234567980"));
-    test(SV("1234567980"), A(2));
-
-    test(SV("123456798012345679801234567980123456798012345679801234567980"));
-    test(SV("123456798012345679801234567980123456798012345679801234567980"), A(2));
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string_view<char, std::char_traits<char> > SV;
+  test(SV(""));
+  test(SV(""), a);
 
-    test(SV(""));
-    test(SV(""), A());
+  test(SV("1"));
+  test(SV("1"), a);
 
-    test(SV("1"));
-    test(SV("1") ,A());
+  test(SV("1234567980"));
+  test(SV("1234567980"), a);
 
-    test(SV("1234567980"));
-    test(SV("1234567980"), A());
+  test(SV("123456798012345679801234567980123456798012345679801234567980"));
+  test(SV("123456798012345679801234567980123456798012345679801234567980"), a);
+}
 
-    test(SV("123456798012345679801234567980123456798012345679801234567980"));
-    test(SV("123456798012345679801234567980123456798012345679801234567980"), A());
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<test_allocator<char> >(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test_string<min_allocator<char> >(min_allocator<char>());
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
@@ -17,15 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(S s1, SV sv)
-{
-    typedef typename S::traits_type T;
-    s1 = sv;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == sv.size());
-    assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, SV sv) {
+  typedef typename S::traits_type T;
+  s1 = sv;
+  LIBCPP_ASSERT(s1.__invariants());
+  assert(s1.size() == sv.size());
+  assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
+  assert(s1.capacity() >= s1.size());
 }
 
 template <class S>
@@ -51,14 +49,13 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
@@ -32,89 +32,69 @@
 #include "min_allocator.h"
 
 template <class StringView, class Allocator, class = void>
-struct CanDeduce : std::false_type { };
+struct CanDeduce : std::false_type {};
 
 template <class StringView, class Allocator>
-struct CanDeduce<StringView, Allocator, decltype((void)
-  std::basic_string{std::declval<StringView>(), std::declval<Allocator>()}
-)> : std::true_type { };
+struct CanDeduce<StringView,
+                 Allocator,
+                 decltype((void)std::basic_string{std::declval<StringView>(), std::declval<Allocator>()})>
+    : std::true_type {};
 
-struct NotAnAllocator { };
-static_assert( CanDeduce<std::string_view, std::allocator<char>>::value);
+struct NotAnAllocator {};
+static_assert(CanDeduce<std::string_view, std::allocator<char> >::value);
 static_assert(!CanDeduce<std::string_view, NotAnAllocator>::value);
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const std::basic_string_view<CharT, std::char_traits<CharT> > sv,
+                               const std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> > s1) {
+  using S = decltype(s1); // what type did we get?
+  static_assert(std::is_same_v<typename S::value_type, CharT>, "");
+  static_assert(std::is_same_v<typename S::traits_type, std::char_traits<CharT> >, "");
+  static_assert(std::is_same_v<typename S::allocator_type, Alloc<CharT> >, "");
+  assert(s1.size() == sv.size());
+  assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1(sv);
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
-
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, std::allocator<char>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, test_allocator<wchar_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<wchar_t, test_allocator>(std::move(sv), std::move(s1));
   }
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, min_allocator<char8_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char8_t, min_allocator>(std::move(sv), std::move(s1));
   }
 #endif
   {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, min_allocator<char16_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char16_t, min_allocator>(std::move(sv), std::move(s1));
   }
   {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, explicit_allocator<char32_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char32_t, explicit_allocator>(std::move(sv), std::move(s1));
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
@@ -36,89 +36,73 @@
 #include "min_allocator.h"
 
 template <class StringView, class Size, class Allocator, class = void>
-struct CanDeduce : std::false_type { };
+struct CanDeduce : std::false_type {};
 
 template <class StringView, class Size, class Allocator>
-struct CanDeduce<StringView, Size, Allocator, decltype((void)
-  std::basic_string{std::declval<StringView>(), std::declval<Size>(), std::declval<Size>(), std::declval<Allocator>()}
-)> : std::true_type { };
+struct CanDeduce<
+    StringView,
+    Size,
+    Allocator,
+    decltype((void)std::basic_string{
+        std::declval<StringView>(), std::declval<Size>(), std::declval<Size>(), std::declval<Allocator>()})>
+    : std::true_type {};
 
-struct NotAnAllocator { };
-static_assert( CanDeduce<std::string_view, std::size_t, std::allocator<char>>::value);
+struct NotAnAllocator {};
+static_assert(CanDeduce<std::string_view, std::size_t, std::allocator<char> >::value);
 static_assert(!CanDeduce<std::string_view, std::size_t, NotAnAllocator>::value);
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const std::basic_string_view<CharT, std::char_traits<CharT> > sv,
+                               const std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> > s1) {
+  using S = decltype(s1); // what type did we get?
+  static_assert(std::is_same_v<typename S::value_type, CharT>, "");
+  static_assert(std::is_same_v<typename S::traits_type, std::char_traits<CharT> >, "");
+  static_assert(std::is_same_v<typename S::allocator_type, Alloc<CharT> >, "");
+  assert(s1.size() == 4);
+  assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
 
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4, std::allocator<char>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, 0, 4, test_allocator<wchar_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<wchar_t, test_allocator>(std::move(sv), std::move(s1));
   }
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char8_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char8_t, min_allocator>(std::move(sv), std::move(s1));
   }
 #endif
   {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char16_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char16_t, min_allocator>(std::move(sv), std::move(s1));
   }
   {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, 0, 4, explicit_allocator<char32_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char32_t, explicit_allocator>(std::move(sv), std::move(s1));
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -28,201 +28,188 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S str, unsigned pos)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-
-    if (pos <= str.size())
-    {
-        S s2(str, pos);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = str.size() - pos;
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos) {
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+
+  if (pos <= str.size()) {
+    S s2(str, pos);
+    LIBCPP_ASSERT(s2.__invariants());
+    typename S::size_type rlen = str.size() - pos;
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == A());
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(str, pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(str, pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S str, unsigned pos, unsigned n)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    if (pos <= str.size())
-    {
-        S s2(str, pos, n);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos, unsigned n) {
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  if (pos <= str.size()) {
+    S s2(str, pos, n);
+    LIBCPP_ASSERT(s2.__invariants());
+    typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == A());
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(str, pos, n);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(str, pos, n);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
-{
-    typedef typename S::traits_type T;
-
-    if (pos <= str.size())
-    {
-        S s2(str, pos, n, a);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == a);
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a) {
+  typedef typename S::traits_type T;
+
+  if (pos <= str.size()) {
+    S s2(str, pos, n, a);
+    LIBCPP_ASSERT(s2.__invariants());
+    typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == a);
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(str, pos, n, a);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(str, pos, n, a);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
-void test_lwg2583()
-{
+void test_lwg2583() {
 #if TEST_STD_VER >= 11 && !defined(TEST_HAS_NO_EXCEPTIONS)
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringA;
-    std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA>>> vs;
-    StringA s{"1234"};
-    vs.emplace_back(s, 2);
-
-    try { vs.emplace_back(s, 5); }
-    catch (const std::out_of_range&) { return; }
-    assert(false);
+  typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > StringA;
+  std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA> > > vs;
+  StringA s{"1234"};
+  vs.emplace_back(s, 2);
+
+  try {
+    vs.emplace_back(s, 5);
+  } catch (const std::out_of_range&) {
+    return;
+  }
+  assert(false);
 #endif
 }
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+
+  test(S(A()), 0);
+  test(S(A()), 1);
+  test(S("1", A()), 0);
+  test(S("1", A()), 1);
+  test(S("1", A()), 2);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 5);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 500);
+
+  test(S(A()), 0, 0);
+  test(S(A()), 0, 1);
+  test(S(A()), 1, 0);
+  test(S(A()), 1, 1);
+  test(S(A()), 1, 2);
+  test(S("1", A()), 0, 0);
+  test(S("1", A()), 0, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100);
+
+  test(S(A()), 0, 0, A());
+  test(S(A()), 0, 1, A());
+  test(S(A()), 1, 0, A());
+  test(S(A()), 1, 1, A());
+  test(S(A()), 1, 2, A());
+  test(S("1", A()), 0, 0, A());
+  test(S("1", A()), 0, 1, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+
+  test(S(A(3)), 0);
+  test(S(A(3)), 1);
+  test(S("1", A(5)), 0);
+  test(S("1", A(5)), 1);
+  test(S("1", A(5)), 2);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 5);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 500);
+
+  test(S(A(3)), 0, 0);
+  test(S(A(3)), 0, 1);
+  test(S(A(3)), 1, 0);
+  test(S(A(3)), 1, 1);
+  test(S(A(3)), 1, 2);
+  test(S("1", A(5)), 0, 0);
+  test(S("1", A(5)), 0, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100);
+
+  test(S(A(3)), 0, 0, A(4));
+  test(S(A(3)), 0, 1, A(4));
+  test(S(A(3)), 1, 0, A(4));
+  test(S(A(3)), 1, 1, A(4));
+  test(S(A(3)), 1, 2, A(4));
+  test(S("1", A(5)), 0, 0, A(6));
+  test(S("1", A(5)), 0, 1, A(6));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0, A(8));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1, A(8));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-
-    test(S(A(3)), 0);
-    test(S(A(3)), 1);
-    test(S("1", A(5)), 0);
-    test(S("1", A(5)), 1);
-    test(S("1", A(5)), 2);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 5);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 500);
-
-    test(S(A(3)), 0, 0);
-    test(S(A(3)), 0, 1);
-    test(S(A(3)), 1, 0);
-    test(S(A(3)), 1, 1);
-    test(S(A(3)), 1, 2);
-    test(S("1", A(5)), 0, 0);
-    test(S("1", A(5)), 0, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100);
-
-    test(S(A(3)), 0, 0, A(4));
-    test(S(A(3)), 0, 1, A(4));
-    test(S(A(3)), 1, 0, A(4));
-    test(S(A(3)), 1, 1, A(4));
-    test(S(A(3)), 1, 2, A(4));
-    test(S("1", A(5)), 0, 0, A(6));
-    test(S("1", A(5)), 0, 1, A(6));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0, A(8));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1, A(8));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
-  }
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-
-    test(S(A()), 0);
-    test(S(A()), 1);
-    test(S("1", A()), 0);
-    test(S("1", A()), 1);
-    test(S("1", A()), 2);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 5);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 500);
-
-    test(S(A()), 0, 0);
-    test(S(A()), 0, 1);
-    test(S(A()), 1, 0);
-    test(S(A()), 1, 1);
-    test(S(A()), 1, 2);
-    test(S("1", A()), 0, 0);
-    test(S("1", A()), 0, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100);
-
-    test(S(A()), 0, 0, A());
-    test(S(A()), 0, 1, A());
-    test(S(A()), 1, 0, A());
-    test(S(A()), 1, 1, A());
-    test(S(A()), 1, 2, A());
-    test(S("1", A()), 0, 0, A());
-    test(S("1", A()), 0, 1, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
-  }
+  { test_string<char, min_allocator>(); }
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp b/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp
@@ -16,27 +16,28 @@
 
 #include "test_macros.h"
 
-constexpr bool test()
-{
-    using S = std::string;
-
-    S s1 {};
-    S s2 {"abcde", 5};
-
-    ASSERT_NOEXCEPT(s1.contains('e'));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s1{};
+  S s2{"abcde", 5};
+
+  ASSERT_NOEXCEPT(s1.contains('e'));
+
+  assert(!s1.contains('c'));
+  assert(!s1.contains('e'));
+  assert(!s1.contains('x'));
+  assert(s2.contains('c'));
+  assert(s2.contains('e'));
+  assert(!s2.contains('x'));
+}
 
-    assert(!s1.contains('c'));
-    assert(!s1.contains('e'));
-    assert(!s1.contains('x'));
-    assert( s2.contains('c'));
-    assert( s2.contains('e'));
-    assert(!s2.contains('x'));
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 
-    return true;
+  return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
diff --git a/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp b/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp
@@ -16,57 +16,58 @@
 
 #include "test_macros.h"
 
-constexpr bool test()
-{
-    using S = std::string;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  const char* s = "abcde";
+  S s0;
+  S s1{s + 4, 1};
+  S s3{s + 2, 3};
+  S sNot{"xyz", 3};
 
-    const char* s = "abcde";
-    S s0;
-    S s1 {s + 4, 1};
-    S s3 {s + 2, 3};
-    S sNot {"xyz", 3};
+  assert(s0.contains(""));
+  assert(!s0.contains("e"));
 
-    assert(s0.contains(""));
-    assert(!s0.contains("e"));
+  assert(s1.contains(""));
+  assert(!s1.contains("d"));
+  assert(s1.contains("e"));
+  assert(!s1.contains("de"));
+  assert(!s1.contains("cd"));
+  assert(!s1.contains("cde"));
+  assert(!s1.contains("bcde"));
+  assert(!s1.contains("abcde"));
+  assert(!s1.contains("xyz"));
 
-    assert( s1.contains(""));
-    assert(!s1.contains("d"));
-    assert( s1.contains("e"));
-    assert(!s1.contains("de"));
-    assert(!s1.contains("cd"));
-    assert(!s1.contains("cde"));
-    assert(!s1.contains("bcde"));
-    assert(!s1.contains("abcde"));
-    assert(!s1.contains("xyz"));
+  assert(s3.contains(""));
+  assert(s3.contains("d"));
+  assert(s3.contains("e"));
+  assert(s3.contains("de"));
+  assert(s3.contains("cd"));
+  assert(!s3.contains("ce"));
+  assert(s3.contains("cde"));
+  assert(!s3.contains("edc"));
+  assert(!s3.contains("bcde"));
+  assert(!s3.contains("abcde"));
+  assert(!s3.contains("xyz"));
 
-    assert( s3.contains(""));
-    assert( s3.contains("d"));
-    assert( s3.contains("e"));
-    assert( s3.contains("de"));
-    assert( s3.contains("cd"));
-    assert(!s3.contains("ce"));
-    assert( s3.contains("cde"));
-    assert(!s3.contains("edc"));
-    assert(!s3.contains("bcde"));
-    assert(!s3.contains("abcde"));
-    assert(!s3.contains("xyz"));
+  assert(sNot.contains(""));
+  assert(!sNot.contains("d"));
+  assert(!sNot.contains("e"));
+  assert(!sNot.contains("de"));
+  assert(!sNot.contains("cd"));
+  assert(!sNot.contains("cde"));
+  assert(!sNot.contains("bcde"));
+  assert(!sNot.contains("abcde"));
+  assert(sNot.contains("xyz"));
+  assert(!sNot.contains("zyx"));
+}
 
-    assert( sNot.contains(""));
-    assert(!sNot.contains("d"));
-    assert(!sNot.contains("e"));
-    assert(!sNot.contains("de"));
-    assert(!sNot.contains("cd"));
-    assert(!sNot.contains("cde"));
-    assert(!sNot.contains("bcde"));
-    assert(!sNot.contains("abcde"));
-    assert( sNot.contains("xyz"));
-    assert(!sNot.contains("zyx"));
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 
-    return true;
+  return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
diff --git a/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp
@@ -16,78 +16,81 @@
 
 #include "test_macros.h"
 
-constexpr bool test()
-{
-    using S = std::string;
-    using SV = std::string_view;
-
-    const char* s = "abcde";
-    S s0;
-    S s1 {s + 1, 1};
-    S s3 {s + 1, 3};
-    S s5 {s    , 5};
-    S sNot {"xyz", 3};
-
-    SV sv0;
-    SV sv1 {s + 1, 1};
-    SV sv2 {s + 1, 2};
-    SV sv3 {s + 1, 3};
-    SV sv4 {s + 1, 4};
-    SV sv5 {s    , 5};
-    SV svNot  {"xyz", 3};
-    SV svNot2 {"bd" , 2};
-    SV svNot3 {"dcb", 3};
-
-    ASSERT_NOEXCEPT(s0.contains(sv0));
-
-    assert( s0.contains(sv0));
-    assert(!s0.contains(sv1));
-
-    assert( s1.contains(sv0));
-    assert( s1.contains(sv1));
-    assert(!s1.contains(sv2));
-    assert(!s1.contains(sv3));
-    assert(!s1.contains(sv4));
-    assert(!s1.contains(sv5));
-    assert(!s1.contains(svNot));
-    assert(!s1.contains(svNot2));
-    assert(!s1.contains(svNot3));
-
-    assert( s3.contains(sv0));
-    assert( s3.contains(sv1));
-    assert( s3.contains(sv2));
-    assert( s3.contains(sv3));
-    assert(!s3.contains(sv4));
-    assert(!s3.contains(sv5));
-    assert(!s3.contains(svNot));
-    assert(!s3.contains(svNot2));
-    assert(!s3.contains(svNot3));
-
-    assert( s5.contains(sv0));
-    assert( s5.contains(sv1));
-    assert( s5.contains(sv2));
-    assert( s5.contains(sv3));
-    assert( s5.contains(sv4));
-    assert( s5.contains(sv5));
-    assert(!s5.contains(svNot));
-    assert(!s5.contains(svNot2));
-    assert(!s5.contains(svNot3));
-
-    assert( sNot.contains(sv0));
-    assert(!sNot.contains(sv1));
-    assert(!sNot.contains(sv2));
-    assert(!sNot.contains(sv3));
-    assert(!sNot.contains(sv4));
-    assert(!sNot.contains(sv5));
-    assert( sNot.contains(svNot));
-    assert(!sNot.contains(svNot2));
-    assert(!sNot.contains(svNot3));
-
-    return true;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV = std::basic_string_view< CharT, std::char_traits<CharT> >;
+
+  const char* s = "abcde";
+  S s0;
+  S s1{s + 1, 1};
+  S s3{s + 1, 3};
+  S s5{s, 5};
+  S sNot{"xyz", 3};
+
+  SV sv0;
+  SV sv1{s + 1, 1};
+  SV sv2{s + 1, 2};
+  SV sv3{s + 1, 3};
+  SV sv4{s + 1, 4};
+  SV sv5{s, 5};
+  SV svNot{"xyz", 3};
+  SV svNot2{"bd", 2};
+  SV svNot3{"dcb", 3};
+
+  ASSERT_NOEXCEPT(s0.contains(sv0));
+
+  assert(s0.contains(sv0));
+  assert(!s0.contains(sv1));
+
+  assert(s1.contains(sv0));
+  assert(s1.contains(sv1));
+  assert(!s1.contains(sv2));
+  assert(!s1.contains(sv3));
+  assert(!s1.contains(sv4));
+  assert(!s1.contains(sv5));
+  assert(!s1.contains(svNot));
+  assert(!s1.contains(svNot2));
+  assert(!s1.contains(svNot3));
+
+  assert(s3.contains(sv0));
+  assert(s3.contains(sv1));
+  assert(s3.contains(sv2));
+  assert(s3.contains(sv3));
+  assert(!s3.contains(sv4));
+  assert(!s3.contains(sv5));
+  assert(!s3.contains(svNot));
+  assert(!s3.contains(svNot2));
+  assert(!s3.contains(svNot3));
+
+  assert(s5.contains(sv0));
+  assert(s5.contains(sv1));
+  assert(s5.contains(sv2));
+  assert(s5.contains(sv3));
+  assert(s5.contains(sv4));
+  assert(s5.contains(sv5));
+  assert(!s5.contains(svNot));
+  assert(!s5.contains(svNot2));
+  assert(!s5.contains(svNot3));
+
+  assert(sNot.contains(sv0));
+  assert(!sNot.contains(sv1));
+  assert(!sNot.contains(sv2));
+  assert(!sNot.contains(sv3));
+  assert(!sNot.contains(sv4));
+  assert(!sNot.contains(sv5));
+  assert(sNot.contains(svNot));
+  assert(!sNot.contains(svNot2));
+  assert(!sNot.contains(svNot3));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+
+  return true;
+}
+
+int main(int, char**) {
   test();
   static_assert(test());
 
diff --git a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
@@ -16,25 +16,26 @@
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    S  s1 {};
-    S  s2 { "abcde", 5 };
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s1{};
+  S s2{"abcde", 5};
 
-    ASSERT_NOEXCEPT(s1.ends_with('e'));
+  ASSERT_NOEXCEPT(s1.ends_with('e'));
 
-    assert (!s1.ends_with('e'));
-    assert (!s1.ends_with('x'));
-    assert ( s2.ends_with('e'));
-    assert (!s2.ends_with('x'));
-  }
+  assert(!s1.ends_with('e'));
+  assert(!s1.ends_with('x'));
+  assert(s2.ends_with('e'));
+  assert(!s2.ends_with('x'));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
diff --git a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
@@ -16,48 +16,50 @@
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    const char *s = "abcde";
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  const char* s = "abcde";
 
-    S   s0;
-    S   s1  { s + 4, 1 };
-    S   s2  { s + 3, 2 };
-//  S   s3  { s + 2, 3 };
-//  S   s4  { s + 1, 4 };
-//  S   s5  { s,     5 };
-    S  sNot { "def", 3 };
+  S s0;
+  S s1{s + 4, 1};
+  S s2{s + 3, 2};
+  //  S   s3  { s + 2, 3 };
+  //  S   s4  { s + 1, 4 };
+  //  S   s5  { s,     5 };
+  S sNot{"def", 3};
 
-    LIBCPP_ASSERT_NOEXCEPT(s0.ends_with(""));
+  LIBCPP_ASSERT_NOEXCEPT(s0.ends_with(""));
 
-    assert ( s0.ends_with(""));
-    assert (!s0.ends_with("e"));
+  assert(s0.ends_with(""));
+  assert(!s0.ends_with("e"));
 
-    assert ( s1.ends_with(""));
-    assert ( s1.ends_with("e"));
-    assert (!s1.ends_with("de"));
-    assert (!s1.ends_with("cde"));
-    assert (!s1.ends_with("bcde"));
-    assert (!s1.ends_with("abcde"));
-    assert (!s1.ends_with("def"));
+  assert(s1.ends_with(""));
+  assert(s1.ends_with("e"));
+  assert(!s1.ends_with("de"));
+  assert(!s1.ends_with("cde"));
+  assert(!s1.ends_with("bcde"));
+  assert(!s1.ends_with("abcde"));
+  assert(!s1.ends_with("def"));
 
-    assert ( s2.ends_with(""));
-    assert ( s2.ends_with("e"));
-    assert ( s2.ends_with("de"));
-    assert (!s2.ends_with("cde"));
-    assert (!s2.ends_with("bcde"));
-    assert (!s2.ends_with("abcde"));
-    assert (!s2.ends_with("def"));
+  assert(s2.ends_with(""));
+  assert(s2.ends_with("e"));
+  assert(s2.ends_with("de"));
+  assert(!s2.ends_with("cde"));
+  assert(!s2.ends_with("bcde"));
+  assert(!s2.ends_with("abcde"));
+  assert(!s2.ends_with("def"));
 
-    assert ( sNot.ends_with(""));
-    assert (!sNot.ends_with("e"));
-    assert (!sNot.ends_with("de"));
-    assert (!sNot.ends_with("cde"));
-    assert (!sNot.ends_with("bcde"));
-    assert (!sNot.ends_with("abcde"));
-    assert ( sNot.ends_with("def"));
-  }
+  assert(sNot.ends_with(""));
+  assert(!sNot.ends_with("e"));
+  assert(!sNot.ends_with("de"));
+  assert(!sNot.ends_with("cde"));
+  assert(!sNot.ends_with("bcde"));
+  assert(!sNot.ends_with("abcde"));
+  assert(sNot.ends_with("def"));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 
   return true;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
@@ -16,57 +16,60 @@
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    const char *s = "abcde";
-
-    S   s0;
-    S   s1  { s + 4, 1 };
-    S   s2  { s + 3, 2 };
-//  S   s3  { s + 2, 3 };
-//  S   s4  { s + 1, 4 };
-//  S   s5  { s,     5 };
-    S  sNot { "def", 3 };
-
-    SV  sv0;
-    SV  sv1 { s + 4, 1 };
-    SV  sv2 { s + 3, 2 };
-    SV  sv3 { s + 2, 3 };
-    SV  sv4 { s + 1, 4 };
-    SV  sv5 { s    , 5 };
-    SV svNot {"def", 3 };
-
-    ASSERT_NOEXCEPT(s0.ends_with(sv0));
-
-    assert ( s0.ends_with(sv0));
-    assert (!s0.ends_with(sv1));
-
-    assert ( s1.ends_with(sv0));
-    assert ( s1.ends_with(sv1));
-    assert (!s1.ends_with(sv2));
-    assert (!s1.ends_with(sv3));
-    assert (!s1.ends_with(sv4));
-    assert (!s1.ends_with(sv5));
-    assert (!s1.ends_with(svNot));
-
-    assert ( s2.ends_with(sv0));
-    assert ( s2.ends_with(sv1));
-    assert ( s2.ends_with(sv2));
-    assert (!s2.ends_with(sv3));
-    assert (!s2.ends_with(sv4));
-    assert (!s2.ends_with(sv5));
-    assert (!s2.ends_with(svNot));
-
-    assert ( sNot.ends_with(sv0));
-    assert (!sNot.ends_with(sv1));
-    assert (!sNot.ends_with(sv2));
-    assert (!sNot.ends_with(sv3));
-    assert (!sNot.ends_with(sv4));
-    assert (!sNot.ends_with(sv5));
-    assert ( sNot.ends_with(svNot));
-  }
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using S       = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV      = std::basic_string_view< CharT, std::char_traits<CharT> >;
+  const char* s = "abcde";
+
+  S s0;
+  S s1{s + 4, 1};
+  S s2{s + 3, 2};
+  //  S   s3  { s + 2, 3 };
+  //  S   s4  { s + 1, 4 };
+  //  S   s5  { s,     5 };
+  S sNot{"def", 3};
+
+  SV sv0;
+  SV sv1{s + 4, 1};
+  SV sv2{s + 3, 2};
+  SV sv3{s + 2, 3};
+  SV sv4{s + 1, 4};
+  SV sv5{s, 5};
+  SV svNot{"def", 3};
+
+  ASSERT_NOEXCEPT(s0.ends_with(sv0));
+
+  assert(s0.ends_with(sv0));
+  assert(!s0.ends_with(sv1));
+
+  assert(s1.ends_with(sv0));
+  assert(s1.ends_with(sv1));
+  assert(!s1.ends_with(sv2));
+  assert(!s1.ends_with(sv3));
+  assert(!s1.ends_with(sv4));
+  assert(!s1.ends_with(sv5));
+  assert(!s1.ends_with(svNot));
+
+  assert(s2.ends_with(sv0));
+  assert(s2.ends_with(sv1));
+  assert(s2.ends_with(sv2));
+  assert(!s2.ends_with(sv3));
+  assert(!s2.ends_with(sv4));
+  assert(!s2.ends_with(sv5));
+  assert(!s2.ends_with(svNot));
+
+  assert(sNot.ends_with(sv0));
+  assert(!sNot.ends_with(sv1));
+  assert(!sNot.ends_with(sv2));
+  assert(!sNot.ends_with(sv3));
+  assert(!sNot.ends_with(sv4));
+  assert(!sNot.ends_with(sv5));
+  assert(sNot.ends_with(svNot));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
 
   return true;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
@@ -18,38 +18,32 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::iterator b = s.begin();
-    typename S::const_iterator cb = cs.begin();
-    if (!s.empty())
-    {
-        assert(*b == s[0]);
-    }
-    assert(b == cb);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                   = s;
+  typename S::iterator b        = s.begin();
+  typename S::const_iterator cb = cs.begin();
+  if (!s.empty()) {
+    assert(*b == s[0]);
+  }
+  assert(b == cb);
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
@@ -17,36 +17,30 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_iterator cb = s.cbegin();
-    if (!s.empty())
-    {
-        assert(*cb == s[0]);
-    }
-    assert(cb == s.begin());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_iterator cb = s.cbegin();
+  if (!s.empty()) {
+    assert(*cb == s[0]);
+  }
+  assert(cb == s.begin());
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
@@ -17,32 +17,27 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_iterator ce = s.cend();
-    assert(ce == s.end());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_iterator ce = s.cend();
+  assert(ce == s.end());
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
@@ -17,36 +17,30 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_reverse_iterator cb = s.crbegin();
-    if (!s.empty())
-    {
-        assert(*cb == s.back());
-    }
-    assert(cb == s.rbegin());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_reverse_iterator cb = s.crbegin();
+  if (!s.empty()) {
+    assert(*cb == s.back());
+  }
+  assert(cb == s.rbegin());
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
@@ -17,32 +17,27 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_reverse_iterator ce = s.crend();
-    assert(ce == s.rend());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_reverse_iterator ce = s.crend();
+  assert(ce == s.rend());
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
@@ -19,40 +19,34 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::iterator e = s.end();
-    typename S::const_iterator ce = cs.end();
-    if (s.empty())
-    {
-        assert(e == s.begin());
-        assert(ce == cs.begin());
-    }
-    assert(static_cast<std::size_t>(e - s.begin()) == s.size());
-    assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                   = s;
+  typename S::iterator e        = s.end();
+  typename S::const_iterator ce = cs.end();
+  if (s.empty()) {
+    assert(e == s.begin());
+    assert(ce == cs.begin());
+  }
+  assert(static_cast<std::size_t>(e - s.begin()) == s.size());
+  assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
@@ -18,38 +18,32 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::reverse_iterator b = s.rbegin();
-    typename S::const_reverse_iterator cb = cs.rbegin();
-    if (!s.empty())
-    {
-        assert(*b == s.back());
-    }
-    assert(b == cb);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                           = s;
+  typename S::reverse_iterator b        = s.rbegin();
+  typename S::const_reverse_iterator cb = cs.rbegin();
+  if (!s.empty()) {
+    assert(*b == s.back());
+  }
+  assert(b == cb);
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
@@ -19,40 +19,34 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::reverse_iterator e = s.rend();
-    typename S::const_reverse_iterator ce = cs.rend();
-    if (s.empty())
-    {
-        assert(e == s.rbegin());
-        assert(ce == cs.rbegin());
-    }
-    assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
-    assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                           = s;
+  typename S::reverse_iterator e        = s.rend();
+  typename S::const_reverse_iterator ce = cs.rend();
+  if (s.empty()) {
+    assert(e == s.rbegin());
+    assert(ce == cs.rbegin());
+  }
+  assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
+  assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
+}
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(S());
+  test(S("123"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+  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_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp
@@ -23,16 +23,21 @@
     TEST_CONSTEXPR operator char() const { return ch_; }
 };
 
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    S s;
+    Charlike<Holder<Incomplete> > a[] = {'m', 'a', 'h', 'i'};
+    s.append(a, a + 4);
+    s.assign(a, a + 4);
+    s.insert(s.begin(), a, a + 4);
+    s.replace(s.begin(), s.begin() + 4, a, a + 4);
+    assert(s == "mahimahi");
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
-  std::string s;
-  Charlike<Holder<Incomplete> > a[] = {'m', 'a', 'h', 'i'};
-  s.append(a, a+4);
-  s.assign(a, a+4);
-  s.insert(s.begin(), a, a+4);
-  s.replace(s.begin(), s.begin()+4, a, a+4);
-  assert(s == "mahimahi");
-
-  return true;
+    test_string<std::string>();
+
+    return true;
 }
 
 int main(int, char**)
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
@@ -20,54 +20,40 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
-{
-    if (pos <= sv.size())
-    {
-        s.append(sv, pos, n);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected) {
+  if (pos <= sv.size()) {
+    s.append(sv, pos, n);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(sv, pos, n);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      s.append(sv, pos, n);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > sv.size());
     }
+  }
 #endif
 }
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test_npos(S s, SV sv, typename S::size_type pos, S expected)
-{
-    if (pos <= sv.size())
-    {
-        s.append(sv, pos);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test_npos(S s, SV sv, typename S::size_type pos, S expected) {
+  if (pos <= sv.size()) {
+    s.append(sv, pos);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(sv, pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      s.append(sv, pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > sv.size());
     }
+  }
 #endif
 }
 
@@ -100,7 +86,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   {
@@ -177,8 +163,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
@@ -18,24 +18,23 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s("123");
+  s.append({'a', 'b', 'c'});
+  assert(s == "123abc");
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s("123");
-    s.append({'a', 'b', 'c'});
-    assert(s == "123abc");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s("123");
-    s.append({'a', 'b', 'c'});
-    assert(s == "123abc");
-  }
+  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**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -19,16 +19,16 @@
 #include "min_allocator.h"
 
 template <class S, class It>
-TEST_CONSTEXPR_CXX20 void
-test(S s, It first, It last, S expected)
-{
-    s.append(first, last);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, It first, It last, S expected) {
+  s.append(first, last);
+  LIBCPP_ASSERT(s.__invariants());
+  assert(s == expected);
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-struct Widget { operator char() const { throw 42; } };
+struct Widget {
+  operator char() const { throw 42; }
+};
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
@@ -114,7 +114,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
@@ -162,38 +162,42 @@
   }
 
   { // regression-test appending to self in sneaky ways
-    std::string s_short = "hello";
-    std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
-    std::string s_othertype = "hello";
-    std::string s_sneaky = "hello";
+    typedef std::string S;
+    S s_short     = "hello";
+    S s_long      = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_othertype = "hello";
+    S s_sneaky    = "hello";
 
-    test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
-         std::string("hello\0", 6));
-    test(s_long, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
-         std::string("Lorem ipsum dolor sit amet, consectetur/\0", 41));
+    test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1, S("hello\0", 6));
+    test(s_long,
+         s_long.data() + s_long.size(),
+         s_long.data() + s_long.size() + 1,
+         S("Lorem ipsum dolor sit amet, consectetur/\0", 41));
 
     s_sneaky.reserve(12);
-    test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, std::string("hellohello\0", 11));
+    test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, S("hellohello\0", 11));
 
-     if (!TEST_IS_CONSTANT_EVALUATED) {
-       const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
-       test(s_othertype, first + 2, first + 5, std::string("hellollo"));
-     }
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+      const unsigned char* first = reinterpret_cast<const unsigned char*>(s_othertype.data());
+      test(s_othertype, first + 2, first + 5, S("hellollo"));
+    }
   }
 
   { // test with a move iterator that returns char&&
+    typedef std::string S;
     typedef forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
-    std::string s;
+    S s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
   { // test with a move iterator that returns char&&
+    typedef std::string S;
     typedef const char* It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
-    std::string s;
+    S s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
@@ -201,8 +205,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -18,12 +18,10 @@
 #include "min_allocator.h"
 
 template <class S>
-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 void test(S s, const typename S::value_type* str, S expected) {
+  s.append(str);
+  LIBCPP_ASSERT(s.__invariants());
+  assert(s == expected);
 }
 
 template <class S>
@@ -45,7 +43,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   { // test appending to self
@@ -66,8 +64,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -19,12 +19,10 @@
 #include "min_allocator.h"
 
 template <class S>
-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 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);
 }
 
 template <class S>
@@ -50,7 +48,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   { // test appending to self
@@ -72,8 +70,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -57,45 +57,38 @@
 } // end namespace std
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::value_type c, S expected)
-{
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::value_type c, S expected) {
     s.push_back(c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(), 'a', S(1, 'a'));
     test(S("12345"), 'a', S("12345a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-  }
+}
+
+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', S(1, 'a'));
-    test(S("12345"), 'a', S("12345a"));
-    test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
+    {
+      // https://llvm.org/PR31454
+      std::basic_string<VeryLarge> s;
+      VeryLarge vl = {};
+      s.push_back(vl);
+      s.push_back(vl);
+      s.push_back(vl);
+    }
 
-  {
-    // https://llvm.org/PR31454
-    std::basic_string<VeryLarge> s;
-    VeryLarge vl = {};
-    s.push_back(vl);
-    s.push_back(vl);
-    s.push_back(vl);
-  }
-
-  return true;
+    return true;
 }
 
-int main(int, char**)
-{
-  test();
+int main(int, char**) {
+    test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
@@ -18,12 +18,10 @@
 #include "min_allocator.h"
 
 template <class S>
-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 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);
 }
 
 template <class S>
@@ -45,14 +43,12 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
-
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
@@ -18,12 +18,10 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, S str, S expected)
-{
-    s.append(str);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, S str, S expected) {
+  s.append(str);
+  LIBCPP_ASSERT(s.__invariants());
+  assert(s == expected);
 }
 
 template <class S>
@@ -53,7 +51,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
 #if TEST_STD_VER >= 11
@@ -68,8 +66,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
@@ -20,54 +20,40 @@
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
-{
-    if (pos <= str.size())
-    {
-        s.append(str, pos, n);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected) {
+  if (pos <= str.size()) {
+    s.append(str, pos, n);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(str, pos, n);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      s.append(str, pos, n);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test_npos(S s, S str, typename S::size_type pos, S expected)
-{
-    if (pos <= str.size())
-    {
-        s.append(str, pos);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test_npos(S s, S str, typename S::size_type pos, S expected) {
+  if (pos <= str.size()) {
+    s.append(str, pos);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(str, pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      s.append(str, pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
@@ -99,7 +85,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   {
@@ -116,8 +102,7 @@
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
@@ -19,12 +19,10 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(S s, SV sv, S expected)
-{
-    s.append(sv);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, SV sv, S expected) {
+  s.append(sv);
+  LIBCPP_ASSERT(s.__invariants());
+  assert(s == expected);
 }
 
 template <class S>
@@ -55,14 +53,12 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
-
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
@@ -99,7 +99,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   {
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
@@ -18,18 +18,18 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s("123");
+  s.assign({'a', 'b', 'c'});
+  assert(s == "abc");
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s("123");
-    s.assign({'a', 'b', 'c'});
-    assert(s == "abc");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s("123");
-    s.assign({'a', 'b', 'c'});
-    assert(s == "abc");
-  }
+  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;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -114,7 +114,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
@@ -123,16 +123,16 @@
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
-    test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
-    test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s + 10, 4, TIter::TAIncrement)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s + 10, 5, TIter::TADereference)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s + 10, 6, TIter::TAComparison)), IIter(TIter()));
 
-    test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
-    test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
-    test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
+    test_exceptions(S(), TIter(s, s + 10, 4, TIter::TAIncrement), TIter());
+    test_exceptions(S(), TIter(s, s + 10, 5, TIter::TADereference), TIter());
+    test_exceptions(S(), TIter(s, s + 10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
-    test_exceptions(S(), w, w+100);
+    test_exceptions(S(), w, w + 100);
   }
 #endif
 
@@ -163,9 +163,10 @@
   }
 
   { // regression-test assigning to self in sneaky ways
-    std::string sneaky = "hello";
+    typedef std::string S;
+    S sneaky = "hello";
     sneaky.resize(sneaky.capacity(), 'x');
-    std::string expected = sneaky + std::string(1, '\0');
+    S expected = sneaky + S(1, '\0');
     test(sneaky, sneaky.data(), sneaky.data() + sneaky.size() + 1, expected);
   }
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -45,7 +45,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   { // test assignment to self
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -50,7 +50,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   { // test assign to self
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
@@ -54,7 +54,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
@@ -45,7 +45,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
@@ -37,9 +37,11 @@
     assert(s.get_allocator() == a);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using A = Alloc<CharT>;
+    using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+
     test(S(), S(), S());
     test(S(), S("12345"), S("12345"));
     test(S(), S("1234567890"), S("1234567890"));
@@ -58,53 +60,30 @@
     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(S("12345678901234567890"), S("12345678901234567890"), S("12345678901234567890"));
 
-    testAlloc(S(), S(), std::allocator<char>());
-    testAlloc(S(), S("12345"), std::allocator<char>());
-    testAlloc(S(), S("1234567890"), std::allocator<char>());
-    testAlloc(S(), S("12345678901234567890"), std::allocator<char>());
-  }
+    testAlloc(S(), S(), Alloc<CharT>());
+    testAlloc(S(), S("12345"), Alloc<CharT>());
+    testAlloc(S(), S("1234567890"), Alloc<CharT>());
+    testAlloc(S(), S("12345678901234567890"), Alloc<CharT>());
+}
 
-  { //  LWG#5579 make sure assign takes the allocators where appropriate
-    typedef other_allocator<char> A;  // has POCCA --> true
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, other_allocator>() {
+    //  LWG#5579 make sure assign takes the allocators where appropriate
+    using A = other_allocator<char>;
+    using S = std::basic_string<char, std::char_traits<char>, A>;
     testAlloc(S(A(5)), S(A(3)), A(3));
     testAlloc(S(A(5)), S("1"), A());
     testAlloc(S(A(5)), S("1", A(7)), A(7));
     testAlloc(S(A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7));
-  }
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
+    test_string<char, other_allocator>(); // has POCCA --> true
 #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"));
-
-    testAlloc(S(), S(), min_allocator<char>());
-    testAlloc(S(), S("12345"), min_allocator<char>());
-    testAlloc(S(), S("1234567890"), min_allocator<char>());
-    testAlloc(S(), S("12345678901234567890"), min_allocator<char>());
-  }
+    test_string<char, min_allocator>();
 #endif
 #if TEST_STD_VER > 14
   {
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
@@ -99,7 +99,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   {
@@ -112,7 +112,6 @@
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
   }
-
   return true;
 }
 
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
@@ -73,7 +73,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
@@ -115,9 +115,8 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
-
   return true;
 }
 
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
@@ -47,7 +47,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
@@ -90,9 +90,8 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
-
   return true;
 }
 
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
@@ -36,7 +36,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
@@ -195,7 +195,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
@@ -54,7 +54,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
@@ -19,20 +19,17 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s("123456");
+  typename S::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
+  assert(i - s.begin() == 3);
+  assert(s == "123abc456");
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s("123456");
-    std::string::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
-    assert(i - s.begin() == 3);
-    assert(s == "123abc456");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s("123456");
-    S::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
-    assert(i - s.begin() == 3);
-    assert(s == "123abc456");
-  }
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return true;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -105,7 +105,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
@@ -99,7 +99,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
@@ -1903,8 +1903,8 @@
 {
   test<std::string, std::string_view>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>,
-       std::basic_string_view<char, std::char_traits<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> >,
+       std::basic_string_view<char, std::char_traits<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -134,7 +134,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   { // test inserting into self
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -372,7 +372,6 @@
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 20, S("can't happen"));
   }
-
   { // test inserting into self
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
@@ -395,12 +394,12 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
 #if TEST_STD_VER > 17
   static_assert(test<std::string>());
-  static_assert(test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>());
+  static_assert(test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
@@ -135,7 +135,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
@@ -134,7 +134,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
 #if TEST_STD_VER >= 11
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
@@ -1862,7 +1862,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -135,7 +135,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   { // test inserting into self
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
@@ -25,22 +25,18 @@
     assert(s == expected);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(), 'a', S("a"));
     test(S("12345"), 'a', S("12345a"));
     test(S("1234567890"), 'a', S("1234567890a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-  }
+}
+
+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', S("a"));
-    test(S("12345"), 'a', S("12345a"));
-    test(S("1234567890"), 'a', S("1234567890a"));
-    test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
@@ -18,19 +18,16 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s("123");
-    s += {'a', 'b', 'c'};
-    assert(s == "123abc");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s("123");
-    s += {'a', 'b', 'c'};
-    assert(s == "123abc");
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s("123");
+  s += {'a', 'b', 'c'};
+  assert(s == "123abc");
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
   return true;
 }
 
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
@@ -52,7 +52,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
@@ -53,10 +53,7 @@
 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 >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
   { // LWG 2946
     std::string s;
     s += {"abc", 1};
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
@@ -18,18 +18,16 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s("123def456");
+  s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
+  assert(s == "123abc456");
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s("123def456");
-    s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
-    assert(s == "123abc456");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s("123def456");
-    s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
-    assert(s == "123abc456");
-  }
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return true;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -1074,8 +1074,8 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
-}
+}
\ No newline at end of file
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
@@ -287,9 +287,8 @@
     return true;
 }
 
+template <class S>
 TEST_CONSTEXPR_CXX20 void test() {
-  {
-    typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
@@ -297,26 +296,15 @@
     static_assert(test0<S>());
     static_assert(test1<S>());
     static_assert(test2<S>());
-#endif
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-#if TEST_STD_VER > 17
-    static_assert(test0<S>());
-    static_assert(test1<S>());
-    static_assert(test2<S>());
-#endif
-  }
 #endif
 }
 
 int main(int, char**)
 {
-  test();
+    test<std::string>();
+#if TEST_STD_VER >= 11
+    test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+#endif
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -1010,8 +1010,8 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
-}
+}
\ No newline at end of file
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
@@ -35,8 +35,7 @@
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test0()
-{
+TEST_CONSTEXPR_CXX20 bool test0() {
     test(S(""), 0, 0, 0, '3', S(""));
     test(S(""), 0, 0, 5, '3', S("33333"));
     test(S(""), 0, 0, 10, '3', S("3333333333"));
@@ -137,11 +136,11 @@
     test(S("abcdefghij"), 1, 1, 5, '3', S("a33333cdefghij"));
     test(S("abcdefghij"), 1, 1, 10, '3', S("a3333333333cdefghij"));
     test(S("abcdefghij"), 1, 1, 20, '3', S("a33333333333333333333cdefghij"));
+    return true;
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test1()
-{
+TEST_CONSTEXPR_CXX20 bool test1() {
     test(S("abcdefghij"), 1, 4, 0, '3', S("afghij"));
     test(S("abcdefghij"), 1, 4, 5, '3', S("a33333fghij"));
     test(S("abcdefghij"), 1, 4, 10, '3', S("a3333333333fghij"));
@@ -242,11 +241,11 @@
     test(S("abcdefghijklmnopqrst"), 10, 9, 5, '3', S("abcdefghij33333t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, 10, '3', S("abcdefghij3333333333t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, 20, '3', S("abcdefghij33333333333333333333t"));
+    return true;
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test2()
-{
+TEST_CONSTEXPR_CXX20 bool test2() {
     test(S("abcdefghijklmnopqrst"), 10, 10, 0, '3', S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, 5, '3', S("abcdefghij33333"));
     test(S("abcdefghijklmnopqrst"), 10, 10, 10, '3', S("abcdefghij3333333333"));
@@ -263,33 +262,28 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, 5, '3', S("abcdefghijklmnopqrst33333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 10, '3', S("abcdefghijklmnopqrst3333333333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 20, '3', S("abcdefghijklmnopqrst33333333333333333333"));
+    return true;
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test() {
     test0<S>();
     test1<S>();
     test2<S>();
-  }
-#endif
 
-  return true;
+#if TEST_STD_VER > 17
+    static_assert(test0<S>());
+    static_assert(test1<S>());
+    static_assert(test2<S>());
+#endif
 }
 
 int main(int, char**)
 {
-  test();
-#if TEST_STD_VER > 17
-  static_assert(test());
+    test<std::string>();
+#if TEST_STD_VER >= 11
+    test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
-}
+}
\ No newline at end of file
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
@@ -297,7 +297,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
@@ -270,10 +270,10 @@
     return true;
 }
 
+template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
@@ -281,27 +281,15 @@
     static_assert(test0<S, SV>());
     static_assert(test1<S, SV>());
     static_assert(test2<S, SV>());
-#endif
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
-#if TEST_STD_VER > 17
-    static_assert(test0<S, SV>());
-    static_assert(test1<S, SV>());
-    static_assert(test2<S, SV>());
-#endif
-  }
 #endif
 }
 
 int main(int, char**)
 {
-  test();
+    test<char, std::allocator>();
+#if TEST_STD_VER >= 11
+    test<char, min_allocator>();
+#endif
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
@@ -6016,64 +6016,66 @@
     return true;
 }
 
-template <class S, class SV>
-TEST_CONSTEXPR_CXX20 bool test() {
-  test0<S, SV>();
-  test1<S, SV>();
-  test2<S, SV>();
-  test3<S, SV>();
-  test4<S, SV>();
-  test5<S, SV>();
-  test6<S, SV>();
-  test7<S, SV>();
-  test8<S, SV>();
-  test9<S, SV>();
-  test10<S, SV>();
-  test11<S, SV>();
-  test12<S, SV>();
-  test13<S, SV>();
-  test14<S, SV>();
-  test15<S, SV>();
-  test16<S, SV>();
-  test17<S, SV>();
-  test18<S, SV>();
-  test19<S, SV>();
-  test20<S, SV>();
-  test21<S, SV>();
-  test22<S, SV>();
-  test23<S, SV>();
-  test24<S, SV>();
-  test25<S, SV>();
-  test26<S, SV>();
-  test27<S, SV>();
-  test28<S, SV>();
-  test29<S, SV>();
-  test30<S, SV>();
-  test31<S, SV>();
-  test32<S, SV>();
-  test33<S, SV>();
-  test34<S, SV>();
-  test35<S, SV>();
-  test36<S, SV>();
-  test37<S, SV>();
-  test38<S, SV>();
-  test39<S, SV>();
-  test40<S, SV>();
-  test41<S, SV>();
-  test42<S, SV>();
-  test43<S, SV>();
-  test44<S, SV>();
-  test45<S, SV>();
-  test46<S, SV>();
-  test47<S, SV>();
-  test48<S, SV>();
-  test49<S, SV>();
-  test50<S, SV>();
-  test51<S, SV>();
-  test52<S, SV>();
-  test53<S, SV>();
-  test54<S, SV>();
-  test55<S, SV>();
+template <class CharT, template <class> class Alloc>
+void test() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+    test0<S, SV>();
+    test1<S, SV>();
+    test2<S, SV>();
+    test3<S, SV>();
+    test4<S, SV>();
+    test5<S, SV>();
+    test6<S, SV>();
+    test7<S, SV>();
+    test8<S, SV>();
+    test9<S, SV>();
+    test10<S, SV>();
+    test11<S, SV>();
+    test12<S, SV>();
+    test13<S, SV>();
+    test14<S, SV>();
+    test15<S, SV>();
+    test16<S, SV>();
+    test17<S, SV>();
+    test18<S, SV>();
+    test19<S, SV>();
+    test20<S, SV>();
+    test21<S, SV>();
+    test22<S, SV>();
+    test23<S, SV>();
+    test24<S, SV>();
+    test25<S, SV>();
+    test26<S, SV>();
+    test27<S, SV>();
+    test28<S, SV>();
+    test29<S, SV>();
+    test30<S, SV>();
+    test31<S, SV>();
+    test32<S, SV>();
+    test33<S, SV>();
+    test34<S, SV>();
+    test35<S, SV>();
+    test36<S, SV>();
+    test37<S, SV>();
+    test38<S, SV>();
+    test39<S, SV>();
+    test40<S, SV>();
+    test41<S, SV>();
+    test42<S, SV>();
+    test43<S, SV>();
+    test44<S, SV>();
+    test45<S, SV>();
+    test46<S, SV>();
+    test47<S, SV>();
+    test48<S, SV>();
+    test49<S, SV>();
+    test50<S, SV>();
+    test51<S, SV>();
+    test52<S, SV>();
+    test53<S, SV>();
+    test54<S, SV>();
+    test55<S, SV>();
 
 #if TEST_STD_VER > 17
   static_assert(test0<S, SV>());
@@ -6133,16 +6135,13 @@
   static_assert(test54<S, SV>());
   static_assert(test55<S, SV>());
 #endif
-
-  return true;
 }
 
 int main(int, char**)
 {
-  test<std::string, std::string_view>();
+  test<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>,
-       std::basic_string_view<char, std::char_traits<char>>>();
+  test<char, min_allocator>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
@@ -387,7 +387,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
@@ -1356,7 +1356,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
@@ -387,7 +387,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
@@ -395,7 +395,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -5972,63 +5972,63 @@
 }
 
 template <class S>
-void test() {
-  test0<S>();
-  test1<S>();
-  test2<S>();
-  test3<S>();
-  test4<S>();
-  test5<S>();
-  test6<S>();
-  test7<S>();
-  test8<S>();
-  test9<S>();
-  test10<S>();
-  test11<S>();
-  test12<S>();
-  test13<S>();
-  test14<S>();
-  test15<S>();
-  test16<S>();
-  test17<S>();
-  test18<S>();
-  test19<S>();
-  test20<S>();
-  test21<S>();
-  test22<S>();
-  test23<S>();
-  test24<S>();
-  test25<S>();
-  test26<S>();
-  test27<S>();
-  test28<S>();
-  test29<S>();
-  test30<S>();
-  test31<S>();
-  test32<S>();
-  test33<S>();
-  test34<S>();
-  test35<S>();
-  test36<S>();
-  test37<S>();
-  test38<S>();
-  test39<S>();
-  test40<S>();
-  test41<S>();
-  test42<S>();
-  test43<S>();
-  test44<S>();
-  test45<S>();
-  test46<S>();
-  test47<S>();
-  test48<S>();
-  test49<S>();
-  test50<S>();
-  test51<S>();
-  test52<S>();
-  test53<S>();
-  test54<S>();
-  test55<S>();
+TEST_CONSTEXPR_CXX20 void test() {
+    test0<S>();
+    test1<S>();
+    test2<S>();
+    test3<S>();
+    test4<S>();
+    test5<S>();
+    test6<S>();
+    test7<S>();
+    test8<S>();
+    test9<S>();
+    test10<S>();
+    test11<S>();
+    test12<S>();
+    test13<S>();
+    test14<S>();
+    test15<S>();
+    test16<S>();
+    test17<S>();
+    test18<S>();
+    test19<S>();
+    test20<S>();
+    test21<S>();
+    test22<S>();
+    test23<S>();
+    test24<S>();
+    test25<S>();
+    test26<S>();
+    test27<S>();
+    test28<S>();
+    test29<S>();
+    test30<S>();
+    test31<S>();
+    test32<S>();
+    test33<S>();
+    test34<S>();
+    test35<S>();
+    test36<S>();
+    test37<S>();
+    test38<S>();
+    test39<S>();
+    test40<S>();
+    test41<S>();
+    test42<S>();
+    test43<S>();
+    test44<S>();
+    test45<S>();
+    test46<S>();
+    test47<S>();
+    test48<S>();
+    test49<S>();
+    test50<S>();
+    test51<S>();
+    test52<S>();
+    test53<S>();
+    test54<S>();
+    test55<S>();
 
 #if TEST_STD_VER > 17
   static_assert(test0<S>());
@@ -6094,7 +6094,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
@@ -368,10 +368,10 @@
     return true;
 }
 
-template <class S>
+template <class CharT, template <class> class Alloc>
 void test() {
-  {
-    typedef std::string_view SV;
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
@@ -380,14 +380,13 @@
     static_assert(test1<S, SV>());
     static_assert(test2<S, SV>());
 #endif
-  }
 }
 
 int main(int, char**)
 {
-  test<std::string>();
+    test<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+    test<char, min_allocator>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
@@ -54,7 +54,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
@@ -20,68 +20,45 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream in(" abc\n  def\n   ghij");
-        std::string s("initial text");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == " abc");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == "  def");
-        std::getline(in, s);
-        assert(in.eof());
-        assert(s == "   ghij");
-    }
+template <template <class> class Alloc>
+void test_string() {
+  {
+    using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+    std::istringstream in(" abc\n  def\n   ghij");
+    S s("initial text");
+    std::getline(in, s);
+    assert(in.good());
+    assert(s == " abc");
+    std::getline(in, s);
+    assert(in.good());
+    assert(s == "  def");
+    std::getline(in, s);
+    assert(in.eof());
+    assert(s == "   ghij");
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wistringstream in(L" abc\n  def\n   ghij");
-        std::wstring s(L"initial text");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == L" abc");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == L"  def");
-        std::getline(in, s);
-        assert(in.eof());
-        assert(s == L"   ghij");
-    }
+  {
+    using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+    std::wistringstream in(L" abc\n  def\n   ghij");
+    WS s(L"initial text");
+    std::getline(in, s);
+    assert(in.good());
+    assert(s == L" abc");
+    std::getline(in, s);
+    assert(in.good());
+    assert(s == L"  def");
+    std::getline(in, s);
+    assert(in.eof());
+    assert(s == L"   ghij");
+  }
 #endif
+}
+
+int main(int, char**) {
+  test_string<std::allocator>();
 #if TEST_STD_VER >= 11
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        std::istringstream in(" abc\n  def\n   ghij");
-        S s("initial text");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == " abc");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == "  def");
-        std::getline(in, s);
-        assert(in.eof());
-        assert(s == "   ghij");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::wistringstream in(L" abc\n  def\n   ghij");
-        S s(L"initial text");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == L" abc");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == L"  def");
-        std::getline(in, s);
-        assert(in.eof());
-        assert(s == L"   ghij");
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
-#endif // TEST_STD_VER >= 11
+  test_string<min_allocator>();
+#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::basic_stringbuf<char> sb("hello");
@@ -165,6 +142,4 @@
     }
 #endif
 #endif // TEST_HAS_NO_EXCEPTIONS
-
-    return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
@@ -20,80 +20,51 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream in(" abc*  def**   ghij");
-        std::string s("initial text");
-        std::getline(in, s, '*');
-        assert(in.good());
-        assert(s == " abc");
-        std::getline(in, s, '*');
-        assert(in.good());
-        assert(s == "  def");
-        std::getline(in, s, '*');
-        assert(in.good());
-        assert(s == "");
-        std::getline(in, s, '*');
-        assert(in.eof());
-        assert(s == "   ghij");
-    }
+template <template <class> class Alloc>
+void test_string() {
+  {
+    using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+    std::istringstream in(" abc*  def**   ghij");
+    S s("initial text");
+    std::getline(in, s, '*');
+    assert(in.good());
+    assert(s == " abc");
+    std::getline(in, s, '*');
+    assert(in.good());
+    assert(s == "  def");
+    std::getline(in, s, '*');
+    assert(in.good());
+    assert(s == "");
+    std::getline(in, s, '*');
+    assert(in.eof());
+    assert(s == "   ghij");
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wistringstream in(L" abc*  def**   ghij");
-        std::wstring s(L"initial text");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L" abc");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L"  def");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L"");
-        std::getline(in, s, L'*');
-        assert(in.eof());
-        assert(s == L"   ghij");
-    }
+  {
+    using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+    std::wistringstream in(L" abc*  def**   ghij");
+    WS s(L"initial text");
+    std::getline(in, s, L'*');
+    assert(in.good());
+    assert(s == L" abc");
+    std::getline(in, s, L'*');
+    assert(in.good());
+    assert(s == L"  def");
+    std::getline(in, s, L'*');
+    assert(in.good());
+    assert(s == L"");
+    std::getline(in, s, L'*');
+    assert(in.eof());
+    assert(s == L"   ghij");
+  }
 #endif
+}
+
+int main(int, char**) {
+  test_string<std::allocator>();
 #if TEST_STD_VER >= 11
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        std::istringstream in(" abc*  def**   ghij");
-        S s("initial text");
-        std::getline(in, s, '*');
-        assert(in.good());
-        assert(s == " abc");
-        std::getline(in, s, '*');
-        assert(in.good());
-        assert(s == "  def");
-        std::getline(in, s, '*');
-        assert(in.good());
-        assert(s == "");
-        std::getline(in, s, '*');
-        assert(in.eof());
-        assert(s == "   ghij");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::wistringstream in(L" abc*  def**   ghij");
-        S s(L"initial text");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L" abc");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L"  def");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L"");
-        std::getline(in, s, L'*');
-        assert(in.eof());
-        assert(s == L"   ghij");
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
-#endif // TEST_STD_VER >= 11
+  test_string<min_allocator>();
+#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::basic_stringbuf<char> sb("hello");
@@ -176,6 +147,4 @@
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 #endif // TEST_HAS_NO_EXCEPTIONS
-
-    return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
@@ -20,33 +20,28 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s("initial text");
-        std::getline(std::istringstream(" abc*  def*   ghij"), s, '*');
-        assert(s == " abc");
-    }
+template <template <class> class Alloc>
+void test() {
+  {
+    using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+    S s("initial text");
+    std::getline(std::istringstream(" abc*  def*   ghij"), s, '*');
+    assert(s == " abc");
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
-        std::wstring s(L"initial text");
-        std::getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
-        assert(s == L" abc");
+      using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+      WS s(L"initial text");
+      std::getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
+      assert(s == L" abc");
     }
 #endif
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-        S s("initial text");
-        std::getline(std::istringstream(" abc*  def*   ghij"), s, '*');
-        assert(s == " abc");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t> > S;
-        S s(L"initial text");
-        std::getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
-        assert(s == L" abc");
-    }
+}
+
+int main(int, char**) {
+    test<std::allocator>();
+#if TEST_STD_VER >= 11
+    test<min_allocator>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
@@ -20,34 +20,27 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s("initial text");
-        std::getline(std::istringstream(" abc\n  def\n   ghij"), s);
-        assert(s == " abc");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wstring s(L"initial text");
-        std::getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
-        assert(s == L" abc");
-    }
-#endif
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-        S s("initial text");
-        std::getline(std::istringstream(" abc\n  def\n   ghij"), s);
-        assert(s == " abc");
-    }
+template <template <class> class Alloc>
+void test() {
+  {
+    using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+    S s("initial text");
+    std::getline(std::istringstream(" abc\n  def\n   ghij"), s);
+    assert(s == " abc");
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t> > S;
-        S s(L"initial text");
-        std::getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
-        assert(s == L" abc");
+      using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+      WS s(L"initial text");
+      std::getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
+      assert(s == L" abc");
     }
 #endif
+}
+
+int main(int, char**) {
+    test<std::allocator>();
+    test<min_allocator>();
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
@@ -20,54 +20,63 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream in("a bc defghij");
-        std::string s("initial text");
-        in >> s;
-        assert(in.good());
-        assert(s == "a");
-        assert(in.peek() == ' ');
-        in >> s;
-        assert(in.good());
-        assert(s == "bc");
-        assert(in.peek() == ' ');
-        in.width(3);
-        in >> s;
-        assert(in.good());
-        assert(s == "def");
-        assert(in.peek() == 'g');
-        in >> s;
-        assert(in.eof());
-        assert(s == "ghij");
-        in >> s;
-        assert(in.fail());
-    }
+template <template <class> class Alloc>
+void test_string() {
+  {
+    using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+    std::istringstream in("a bc defghij");
+    S s("initial text");
+    in >> s;
+    assert(in.good());
+    assert(s == "a");
+    assert(in.peek() == ' ');
+    in >> s;
+    assert(in.good());
+    assert(s == "bc");
+    assert(in.peek() == ' ');
+    in.width(3);
+    in >> s;
+    assert(in.good());
+    assert(s == "def");
+    assert(in.peek() == 'g');
+    in >> s;
+    assert(in.eof());
+    assert(s == "ghij");
+    in >> s;
+    assert(in.fail());
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
-        std::wistringstream in(L"a bc defghij");
-        std::wstring s(L"initial text");
-        in >> s;
-        assert(in.good());
-        assert(s == L"a");
-        assert(in.peek() == L' ');
-        in >> s;
-        assert(in.good());
-        assert(s == L"bc");
-        assert(in.peek() == L' ');
-        in.width(3);
-        in >> s;
-        assert(in.good());
-        assert(s == L"def");
-        assert(in.peek() == L'g');
-        in >> s;
-        assert(in.eof());
-        assert(s == L"ghij");
-        in >> s;
-        assert(in.fail());
+      using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+      std::wistringstream in(L"a bc defghij");
+      WS s(L"initial text");
+      in >> s;
+      assert(in.good());
+      assert(s == L"a");
+      assert(in.peek() == L' ');
+      in >> s;
+      assert(in.good());
+      assert(s == L"bc");
+      assert(in.peek() == L' ');
+      in.width(3);
+      in >> s;
+      assert(in.good());
+      assert(s == L"def");
+      assert(in.peek() == L'g');
+      in >> s;
+      assert(in.eof());
+      assert(s == L"ghij");
+      in >> s;
+      assert(in.fail());
     }
 #endif
+}
+
+int main(int, char**) {
+    test_string<std::allocator>();
+#if TEST_STD_VER >= 11
+    test_string<min_allocator>();
+#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::stringbuf sb;
@@ -106,56 +115,6 @@
         assert(threw);
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
-#if TEST_STD_VER >= 11
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        std::istringstream in("a bc defghij");
-        S s("initial text");
-        in >> s;
-        assert(in.good());
-        assert(s == "a");
-        assert(in.peek() == ' ');
-        in >> s;
-        assert(in.good());
-        assert(s == "bc");
-        assert(in.peek() == ' ');
-        in.width(3);
-        in >> s;
-        assert(in.good());
-        assert(s == "def");
-        assert(in.peek() == 'g');
-        in >> s;
-        assert(in.eof());
-        assert(s == "ghij");
-        in >> s;
-        assert(in.fail());
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::wistringstream in(L"a bc defghij");
-        S s(L"initial text");
-        in >> s;
-        assert(in.good());
-        assert(s == L"a");
-        assert(in.peek() == L' ');
-        in >> s;
-        assert(in.good());
-        assert(s == L"bc");
-        assert(in.peek() == L' ');
-        in.width(3);
-        in >> s;
-        assert(in.good());
-        assert(s == L"def");
-        assert(in.peek() == L'g');
-        in >> s;
-        assert(in.eof());
-        assert(s == L"ghij");
-        in >> s;
-        assert(in.fail());
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
-#endif // TEST_STD_VER >= 11
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
@@ -20,77 +20,51 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::ostringstream out;
-        std::string s("some text");
-        out << s;
-        assert(out.good());
-        assert(s == out.str());
-    }
-    {
-        std::ostringstream out;
-        std::string s("some text");
-        out.width(12);
-        out << s;
-        assert(out.good());
-        assert("   " + s == out.str());
-    }
+template <template <class> class Alloc>
+void test() {
+  using S  = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+  using OS = std::basic_ostringstream<char, std::char_traits<char>, Alloc<char> >;
+  {
+    OS out;
+    S s("some text");
+    out << s;
+    assert(out.good());
+    assert(s == out.str());
+  }
+  {
+    OS out;
+    S s("some text");
+    out.width(12);
+    out << s;
+    assert(out.good());
+    assert("   " + s == out.str());
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  using WS  = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+  using WOS = std::basic_ostringstream<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+  {
+    WOS out;
+    WS s(L"some text");
+    out << s;
+    assert(out.good());
+    assert(s == out.str());
+  }
     {
-        std::wostringstream out;
-        std::wstring s(L"some text");
-        out << s;
-        assert(out.good());
-        assert(s == out.str());
-    }
-    {
-        std::wostringstream out;
-        std::wstring s(L"some text");
-        out.width(12);
-        out << s;
-        assert(out.good());
-        assert(L"   " + s == out.str());
+      WOS out;
+      WS s(L"some text");
+      out.width(12);
+      out << s;
+      assert(out.good());
+      assert(L"   " + s == out.str());
     }
 #endif
+}
+
+int main(int, char**) {
+    test<std::allocator>();
+
 #if TEST_STD_VER >= 11
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
-        S s("some text");
-        out << s;
-        assert(out.good());
-        assert(s == out.str());
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
-        S s("some text");
-        out.width(12);
-        out << s;
-        assert(out.good());
-        assert("   " + s == out.str());
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
-        S s(L"some text");
-        out << s;
-        assert(out.good());
-        assert(s == out.str());
-    }
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
-        S s(L"some text");
-        out.width(12);
-        out << s;
-        assert(out.good());
-        assert(L"   " + s == out.str());
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
+    test<min_allocator>();
 #endif // TEST_STD_VER >= 11
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
@@ -33,9 +33,8 @@
     assert(s2 == s1_);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), S(""));
     test(S(""), S("12345"));
     test(S(""), S("1234567890"));
@@ -52,27 +51,12 @@
     test(S("abcdefghijklmnopqrst"), S("12345"));
     test(S("abcdefghijklmnopqrst"), S("1234567890"));
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
-  }
+}
+
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
@@ -47,7 +47,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
@@ -47,7 +47,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
@@ -48,7 +48,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
@@ -47,7 +47,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
@@ -47,7 +47,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
@@ -35,36 +35,24 @@
 }
 #endif
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0('a', S(""), S("a"));
-    test0('a', S("12345"), S("a12345"));
-    test0('a', S("1234567890"), S("a1234567890"));
-    test0('a', S("12345678901234567890"), S("a12345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test0('a', S(""), S("a"));
+  test0('a', S("12345"), S("a12345"));
+  test0('a', S("1234567890"), S("a1234567890"));
+  test0('a', S("12345678901234567890"), S("a12345678901234567890"));
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1('a', S(""), S("a"));
-    test1('a', S("12345"), S("a12345"));
-    test1('a', S("1234567890"), S("a1234567890"));
-    test1('a', S("12345678901234567890"), S("a12345678901234567890"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
-    test0('a', S(""), S("a"));
-    test0('a', S("12345"), S("a12345"));
-    test0('a', S("1234567890"), S("a1234567890"));
-    test0('a', S("12345678901234567890"), S("a12345678901234567890"));
+  test1('a', S(""), S("a"));
+  test1('a', S("12345"), S("a12345"));
+  test1('a', S("1234567890"), S("a1234567890"));
+  test1('a', S("12345678901234567890"), S("a12345678901234567890"));
+#endif
+}
 
-    test1('a', S(""), S("a"));
-    test1('a', S("12345"), S("a12345"));
-    test1('a', S("1234567890"), S("a1234567890"));
-    test1('a', S("12345678901234567890"), S("a12345678901234567890"));
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
@@ -35,97 +35,49 @@
 }
 #endif
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0("", S(""), S(""));
-    test0("", S("12345"), S("12345"));
-    test0("", S("1234567890"), S("1234567890"));
-    test0("", S("12345678901234567890"), S("12345678901234567890"));
-    test0("abcde", S(""), S("abcde"));
-    test0("abcde", S("12345"), S("abcde12345"));
-    test0("abcde", S("1234567890"), S("abcde1234567890"));
-    test0("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
-    test0("abcdefghij", S(""), S("abcdefghij"));
-    test0("abcdefghij", S("12345"), S("abcdefghij12345"));
-    test0("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
-    test0("abcdefghij", S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test0("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
-    test0("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
-    test0("abcdefghijklmnopqrst", S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test0("abcdefghijklmnopqrst", S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test0("", S(""), S(""));
+  test0("", S("12345"), S("12345"));
+  test0("", S("1234567890"), S("1234567890"));
+  test0("", S("12345678901234567890"), S("12345678901234567890"));
+  test0("abcde", S(""), S("abcde"));
+  test0("abcde", S("12345"), S("abcde12345"));
+  test0("abcde", S("1234567890"), S("abcde1234567890"));
+  test0("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
+  test0("abcdefghij", S(""), S("abcdefghij"));
+  test0("abcdefghij", S("12345"), S("abcdefghij12345"));
+  test0("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
+  test0("abcdefghij", S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test0("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
+  test0("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
+  test0("abcdefghijklmnopqrst", S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test0("abcdefghijklmnopqrst", S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1("", S(""), S(""));
-    test1("", S("12345"), S("12345"));
-    test1("", S("1234567890"), S("1234567890"));
-    test1("", S("12345678901234567890"), S("12345678901234567890"));
-    test1("abcde", S(""), S("abcde"));
-    test1("abcde", S("12345"), S("abcde12345"));
-    test1("abcde", S("1234567890"), S("abcde1234567890"));
-    test1("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
-    test1("abcdefghij", S(""), S("abcdefghij"));
-    test1("abcdefghij", S("12345"), S("abcdefghij12345"));
-    test1("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
-    test1("abcdefghij", S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test1("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
-    test1("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
-    test1("abcdefghijklmnopqrst", S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test1("abcdefghijklmnopqrst", S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
-    test0("", S(""), S(""));
-    test0("", S("12345"), S("12345"));
-    test0("", S("1234567890"), S("1234567890"));
-    test0("", S("12345678901234567890"), S("12345678901234567890"));
-    test0("abcde", S(""), S("abcde"));
-    test0("abcde", S("12345"), S("abcde12345"));
-    test0("abcde", S("1234567890"), S("abcde1234567890"));
-    test0("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
-    test0("abcdefghij", S(""), S("abcdefghij"));
-    test0("abcdefghij", S("12345"), S("abcdefghij12345"));
-    test0("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
-    test0("abcdefghij", S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test0("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
-    test0("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
-    test0("abcdefghijklmnopqrst", S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test0("abcdefghijklmnopqrst", S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
+  test1("", S(""), S(""));
+  test1("", S("12345"), S("12345"));
+  test1("", S("1234567890"), S("1234567890"));
+  test1("", S("12345678901234567890"), S("12345678901234567890"));
+  test1("abcde", S(""), S("abcde"));
+  test1("abcde", S("12345"), S("abcde12345"));
+  test1("abcde", S("1234567890"), S("abcde1234567890"));
+  test1("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
+  test1("abcdefghij", S(""), S("abcdefghij"));
+  test1("abcdefghij", S("12345"), S("abcdefghij12345"));
+  test1("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
+  test1("abcdefghij", S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test1("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
+  test1("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
+  test1("abcdefghijklmnopqrst", S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test1("abcdefghijklmnopqrst", S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+#endif
+}
 
-    test1("", S(""), S(""));
-    test1("", S("12345"), S("12345"));
-    test1("", S("1234567890"), S("1234567890"));
-    test1("", S("12345678901234567890"), S("12345678901234567890"));
-    test1("abcde", S(""), S("abcde"));
-    test1("abcde", S("12345"), S("abcde12345"));
-    test1("abcde", S("1234567890"), S("abcde1234567890"));
-    test1("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
-    test1("abcdefghij", S(""), S("abcdefghij"));
-    test1("abcdefghij", S("12345"), S("abcdefghij12345"));
-    test1("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
-    test1("abcdefghij", S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test1("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
-    test1("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
-    test1("abcdefghijklmnopqrst", S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test1("abcdefghijklmnopqrst", S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
@@ -35,36 +35,26 @@
 }
 #endif
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0(S(""), '1', S("1"));
-    test0(S("abcde"), '1', S("abcde1"));
-    test0(S("abcdefghij"), '1', S("abcdefghij1"));
-    test0(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test0(S(""), '1', S("1"));
+  test0(S(""), '1', S("1"));
+  test0(S("abcde"), '1', S("abcde1"));
+  test0(S("abcdefghij"), '1', S("abcdefghij1"));
+  test0(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
+
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1(S(""), '1', S("1"));
-    test1(S("abcde"), '1', S("abcde1"));
-    test1(S("abcdefghij"), '1', S("abcdefghij1"));
-    test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
-    test0(S(""), '1', S("1"));
-    test0(S("abcde"), '1', S("abcde1"));
-    test0(S("abcdefghij"), '1', S("abcdefghij1"));
-    test0(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
+  test1(S(""), '1', S("1"));
+  test1(S("abcde"), '1', S("abcde1"));
+  test1(S("abcdefghij"), '1', S("abcdefghij1"));
+  test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
+#endif
+}
 
-    test1(S(""), '1', S("1"));
-    test1(S("abcde"), '1', S("abcde1"));
-    test1(S("abcdefghij"), '1', S("abcdefghij1"));
-    test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
@@ -35,96 +35,48 @@
 }
 #endif
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0(S(""), "", S(""));
-    test0(S(""), "12345", S("12345"));
-    test0(S(""), "1234567890", S("1234567890"));
-    test0(S(""), "12345678901234567890", S("12345678901234567890"));
-    test0(S("abcde"), "", S("abcde"));
-    test0(S("abcde"), "12345", S("abcde12345"));
-    test0(S("abcde"), "1234567890", S("abcde1234567890"));
-    test0(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
-    test0(S("abcdefghij"), "", S("abcdefghij"));
-    test0(S("abcdefghij"), "12345", S("abcdefghij12345"));
-    test0(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
-    test0(S("abcdefghij"), "12345678901234567890",
-          S("abcdefghij12345678901234567890"));
-    test0(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
-    test0(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
-    test0(S("abcdefghijklmnopqrst"), "1234567890",
-          S("abcdefghijklmnopqrst1234567890"));
-    test0(S("abcdefghijklmnopqrst"), "12345678901234567890",
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test0(S(""), "", S(""));
+  test0(S(""), "12345", S("12345"));
+  test0(S(""), "1234567890", S("1234567890"));
+  test0(S(""), "12345678901234567890", S("12345678901234567890"));
+  test0(S("abcde"), "", S("abcde"));
+  test0(S("abcde"), "12345", S("abcde12345"));
+  test0(S("abcde"), "1234567890", S("abcde1234567890"));
+  test0(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
+  test0(S("abcdefghij"), "", S("abcdefghij"));
+  test0(S("abcdefghij"), "12345", S("abcdefghij12345"));
+  test0(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
+  test0(S("abcdefghij"), "12345678901234567890", S("abcdefghij12345678901234567890"));
+  test0(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
+  test0(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
+  test0(S("abcdefghijklmnopqrst"), "1234567890", S("abcdefghijklmnopqrst1234567890"));
+  test0(S("abcdefghijklmnopqrst"), "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1(S(""), "", S(""));
-    test1(S(""), "12345", S("12345"));
-    test1(S(""), "1234567890", S("1234567890"));
-    test1(S(""), "12345678901234567890", S("12345678901234567890"));
-    test1(S("abcde"), "", S("abcde"));
-    test1(S("abcde"), "12345", S("abcde12345"));
-    test1(S("abcde"), "1234567890", S("abcde1234567890"));
-    test1(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
-    test1(S("abcdefghij"), "", S("abcdefghij"));
-    test1(S("abcdefghij"), "12345", S("abcdefghij12345"));
-    test1(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
-    test1(S("abcdefghij"), "12345678901234567890",
-          S("abcdefghij12345678901234567890"));
-    test1(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
-    test1(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
-    test1(S("abcdefghijklmnopqrst"), "1234567890",
-          S("abcdefghijklmnopqrst1234567890"));
-    test1(S("abcdefghijklmnopqrst"), "12345678901234567890",
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
-    test0(S(""), "", S(""));
-    test0(S(""), "12345", S("12345"));
-    test0(S(""), "1234567890", S("1234567890"));
-    test0(S(""), "12345678901234567890", S("12345678901234567890"));
-    test0(S("abcde"), "", S("abcde"));
-    test0(S("abcde"), "12345", S("abcde12345"));
-    test0(S("abcde"), "1234567890", S("abcde1234567890"));
-    test0(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
-    test0(S("abcdefghij"), "", S("abcdefghij"));
-    test0(S("abcdefghij"), "12345", S("abcdefghij12345"));
-    test0(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
-    test0(S("abcdefghij"), "12345678901234567890",
-          S("abcdefghij12345678901234567890"));
-    test0(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
-    test0(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
-    test0(S("abcdefghijklmnopqrst"), "1234567890",
-          S("abcdefghijklmnopqrst1234567890"));
-    test0(S("abcdefghijklmnopqrst"), "12345678901234567890",
-          S("abcdefghijklmnopqrst12345678901234567890"));
+  test1(S(""), "", S(""));
+  test1(S(""), "12345", S("12345"));
+  test1(S(""), "1234567890", S("1234567890"));
+  test1(S(""), "12345678901234567890", S("12345678901234567890"));
+  test1(S("abcde"), "", S("abcde"));
+  test1(S("abcde"), "12345", S("abcde12345"));
+  test1(S("abcde"), "1234567890", S("abcde1234567890"));
+  test1(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
+  test1(S("abcdefghij"), "", S("abcdefghij"));
+  test1(S("abcdefghij"), "12345", S("abcdefghij12345"));
+  test1(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
+  test1(S("abcdefghij"), "12345678901234567890", S("abcdefghij12345678901234567890"));
+  test1(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
+  test1(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
+  test1(S("abcdefghijklmnopqrst"), "1234567890", S("abcdefghijklmnopqrst1234567890"));
+  test1(S("abcdefghijklmnopqrst"), "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
+#endif
+}
 
-    test1(S(""), "", S(""));
-    test1(S(""), "12345", S("12345"));
-    test1(S(""), "1234567890", S("1234567890"));
-    test1(S(""), "12345678901234567890", S("12345678901234567890"));
-    test1(S("abcde"), "", S("abcde"));
-    test1(S("abcde"), "12345", S("abcde12345"));
-    test1(S("abcde"), "1234567890", S("abcde1234567890"));
-    test1(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
-    test1(S("abcdefghij"), "", S("abcdefghij"));
-    test1(S("abcdefghij"), "12345", S("abcdefghij12345"));
-    test1(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
-    test1(S("abcdefghij"), "12345678901234567890",
-          S("abcdefghij12345678901234567890"));
-    test1(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
-    test1(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
-    test1(S("abcdefghijklmnopqrst"), "1234567890",
-          S("abcdefghijklmnopqrst1234567890"));
-    test1(S("abcdefghijklmnopqrst"), "12345678901234567890",
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
@@ -57,193 +57,83 @@
 }
 #endif
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0(S(""), S(""), S(""));
-    test0(S(""), S("12345"), S("12345"));
-    test0(S(""), S("1234567890"), S("1234567890"));
-    test0(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test0(S("abcde"), S(""), S("abcde"));
-    test0(S("abcde"), S("12345"), S("abcde12345"));
-    test0(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test0(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test0(S("abcdefghij"), S(""), S("abcdefghij"));
-    test0(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test0(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test0(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test0(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test0(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test0(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test0(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test0(S(""), S(""), S(""));
+  test0(S(""), S("12345"), S("12345"));
+  test0(S(""), S("1234567890"), S("1234567890"));
+  test0(S(""), S("12345678901234567890"), S("12345678901234567890"));
+  test0(S("abcde"), S(""), S("abcde"));
+  test0(S("abcde"), S("12345"), S("abcde12345"));
+  test0(S("abcde"), S("1234567890"), S("abcde1234567890"));
+  test0(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test0(S("abcdefghij"), S(""), S("abcdefghij"));
+  test0(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
+  test0(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
+  test0(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test0(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
+  test0(S("abcdefghijklmnopqrst"), S("12345"), S("abcdefghijklmnopqrst12345"));
+  test0(S("abcdefghijklmnopqrst"), S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test0(S("abcdefghijklmnopqrst"), S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1(S(""), S(""), S(""));
-    test1(S(""), S("12345"), S("12345"));
-    test1(S(""), S("1234567890"), S("1234567890"));
-    test1(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test1(S("abcde"), S(""), S("abcde"));
-    test1(S("abcde"), S("12345"), S("abcde12345"));
-    test1(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test1(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test1(S("abcdefghij"), S(""), S("abcdefghij"));
-    test1(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test1(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test1(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test1(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test1(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test1(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test1(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-
-    test2(S(""), S(""), S(""));
-    test2(S(""), S("12345"), S("12345"));
-    test2(S(""), S("1234567890"), S("1234567890"));
-    test2(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test2(S("abcde"), S(""), S("abcde"));
-    test2(S("abcde"), S("12345"), S("abcde12345"));
-    test2(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test2(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test2(S("abcdefghij"), S(""), S("abcdefghij"));
-    test2(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test2(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test2(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test2(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test2(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test2(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test2(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-
-    test3(S(""), S(""), S(""));
-    test3(S(""), S("12345"), S("12345"));
-    test3(S(""), S("1234567890"), S("1234567890"));
-    test3(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test3(S("abcde"), S(""), S("abcde"));
-    test3(S("abcde"), S("12345"), S("abcde12345"));
-    test3(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test3(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test3(S("abcdefghij"), S(""), S("abcdefghij"));
-    test3(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test3(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test3(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test3(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test3(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test3(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test3(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
-    test0(S(""), S(""), S(""));
-    test0(S(""), S("12345"), S("12345"));
-    test0(S(""), S("1234567890"), S("1234567890"));
-    test0(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test0(S("abcde"), S(""), S("abcde"));
-    test0(S("abcde"), S("12345"), S("abcde12345"));
-    test0(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test0(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test0(S("abcdefghij"), S(""), S("abcdefghij"));
-    test0(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test0(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test0(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test0(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test0(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test0(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test0(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-
-    test1(S(""), S(""), S(""));
-    test1(S(""), S("12345"), S("12345"));
-    test1(S(""), S("1234567890"), S("1234567890"));
-    test1(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test1(S("abcde"), S(""), S("abcde"));
-    test1(S("abcde"), S("12345"), S("abcde12345"));
-    test1(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test1(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test1(S("abcdefghij"), S(""), S("abcdefghij"));
-    test1(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test1(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test1(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test1(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test1(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test1(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test1(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-
-    test2(S(""), S(""), S(""));
-    test2(S(""), S("12345"), S("12345"));
-    test2(S(""), S("1234567890"), S("1234567890"));
-    test2(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test2(S("abcde"), S(""), S("abcde"));
-    test2(S("abcde"), S("12345"), S("abcde12345"));
-    test2(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test2(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test2(S("abcdefghij"), S(""), S("abcdefghij"));
-    test2(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test2(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test2(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test2(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test2(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test2(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test2(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
+  test1(S(""), S(""), S(""));
+  test1(S(""), S("12345"), S("12345"));
+  test1(S(""), S("1234567890"), S("1234567890"));
+  test1(S(""), S("12345678901234567890"), S("12345678901234567890"));
+  test1(S("abcde"), S(""), S("abcde"));
+  test1(S("abcde"), S("12345"), S("abcde12345"));
+  test1(S("abcde"), S("1234567890"), S("abcde1234567890"));
+  test1(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test1(S("abcdefghij"), S(""), S("abcdefghij"));
+  test1(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
+  test1(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
+  test1(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test1(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
+  test1(S("abcdefghijklmnopqrst"), S("12345"), S("abcdefghijklmnopqrst12345"));
+  test1(S("abcdefghijklmnopqrst"), S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test1(S("abcdefghijklmnopqrst"), S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+
+  test2(S(""), S(""), S(""));
+  test2(S(""), S("12345"), S("12345"));
+  test2(S(""), S("1234567890"), S("1234567890"));
+  test2(S(""), S("12345678901234567890"), S("12345678901234567890"));
+  test2(S("abcde"), S(""), S("abcde"));
+  test2(S("abcde"), S("12345"), S("abcde12345"));
+  test2(S("abcde"), S("1234567890"), S("abcde1234567890"));
+  test2(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test2(S("abcdefghij"), S(""), S("abcdefghij"));
+  test2(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
+  test2(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
+  test2(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test2(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
+  test2(S("abcdefghijklmnopqrst"), S("12345"), S("abcdefghijklmnopqrst12345"));
+  test2(S("abcdefghijklmnopqrst"), S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test2(S("abcdefghijklmnopqrst"), S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+
+  test3(S(""), S(""), S(""));
+  test3(S(""), S("12345"), S("12345"));
+  test3(S(""), S("1234567890"), S("1234567890"));
+  test3(S(""), S("12345678901234567890"), S("12345678901234567890"));
+  test3(S("abcde"), S(""), S("abcde"));
+  test3(S("abcde"), S("12345"), S("abcde12345"));
+  test3(S("abcde"), S("1234567890"), S("abcde1234567890"));
+  test3(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test3(S("abcdefghij"), S(""), S("abcdefghij"));
+  test3(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
+  test3(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
+  test3(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test3(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
+  test3(S("abcdefghijklmnopqrst"), S("12345"), S("abcdefghijklmnopqrst12345"));
+  test3(S("abcdefghijklmnopqrst"), S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test3(S("abcdefghijklmnopqrst"), S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+#endif
+}
 
-    test3(S(""), S(""), S(""));
-    test3(S(""), S("12345"), S("12345"));
-    test3(S(""), S("1234567890"), S("1234567890"));
-    test3(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test3(S("abcde"), S(""), S("abcde"));
-    test3(S("abcde"), S("12345"), S("abcde12345"));
-    test3(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test3(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test3(S("abcdefghij"), S(""), S("abcdefghij"));
-    test3(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test3(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test3(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test3(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test3(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test3(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test3(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
-#endif // TEST_STD_VER >= 11
+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;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test("", S(""), true);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
@@ -43,27 +42,12 @@
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+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(""), true);
-    test("", S("abcde"), false);
-    test("", S("abcdefghij"), false);
-    test("", S("abcdefghijklmnopqrst"), false);
-    test("abcde", S(""), false);
-    test("abcde", S("abcde"), true);
-    test("abcde", S("abcdefghij"), false);
-    test("abcde", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghij", S(""), false);
-    test("abcdefghij", S("abcde"), false);
-    test("abcdefghij", S("abcdefghij"), true);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghijklmnopqrst", S(""), false);
-    test("abcdefghijklmnopqrst", S("abcde"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), "", true);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
@@ -43,27 +42,12 @@
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-  }
+}
+
+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(""), "", true);
-    test(S(""), "abcde", false);
-    test(S(""), "abcdefghij", false);
-    test(S(""), "abcdefghijklmnopqrst", false);
-    test(S("abcde"), "", false);
-    test(S("abcde"), "abcde", true);
-    test(S("abcde"), "abcdefghij", false);
-    test(S("abcde"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghij"), "", false);
-    test(S("abcdefghij"), "abcde", false);
-    test(S("abcdefghij"), "abcdefghij", true);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghijklmnopqrst"), "", false);
-    test(S("abcdefghijklmnopqrst"), "abcde", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
@@ -25,9 +25,8 @@
     assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), S(""), true);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
@@ -44,27 +43,12 @@
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+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(""), true);
-    test(S(""), S("abcde"), false);
-    test(S(""), S("abcdefghij"), false);
-    test(S(""), S("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), S(""), false);
-    test(S("abcde"), S("abcde"), true);
-    test(S("abcde"), S("abcdefghij"), false);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), S(""), false);
-    test(S("abcdefghij"), S("abcde"), false);
-    test(S("abcdefghij"), S("abcdefghij"), true);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), S(""), false);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
@@ -43,28 +43,12 @@
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(S(""), SV(""), true);
-    test(S(""), SV("abcde"), false);
-    test(S(""), SV("abcdefghij"), false);
-    test(S(""), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), SV(""), false);
-    test(S("abcde"), SV("abcde"), true);
-    test(S("abcde"), SV("abcdefghij"), false);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), SV(""), false);
-    test(S("abcdefghij"), SV("abcde"), false);
-    test(S("abcdefghij"), SV("abcdefghij"), true);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), SV(""), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
@@ -23,10 +23,11 @@
     assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
@@ -43,31 +44,14 @@
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(SV(""), S(""), true);
-    test(SV(""), S("abcde"), false);
-    test(SV(""), S("abcdefghij"), false);
-    test(SV(""), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcde"), S(""), false);
-    test(SV("abcde"), S("abcde"), true);
-    test(SV("abcde"), S("abcdefghij"), false);
-    test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcdefghij"), S(""), false);
-    test(SV("abcdefghij"), S("abcde"), false);
-    test(SV("abcdefghij"), S("abcdefghij"), true);
-    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcdefghijklmnopqrst"), S(""), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<char, min_allocator>();
 #endif
-
-  return true;
+    return true;
 }
 
 int main(int, char**)
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test("", S(""), false);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
@@ -43,27 +42,12 @@
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-  }
+}
+
+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"), false);
-    test("", S("abcdefghij"), false);
-    test("", S("abcdefghijklmnopqrst"), false);
-    test("abcde", S(""), true);
-    test("abcde", S("abcde"), false);
-    test("abcde", S("abcdefghij"), false);
-    test("abcde", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghij", S(""), true);
-    test("abcdefghij", S("abcde"), true);
-    test("abcdefghij", S("abcdefghij"), false);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghijklmnopqrst", S(""), true);
-    test("abcdefghijklmnopqrst", S("abcde"), true);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), true);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), "", false);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
@@ -43,27 +42,12 @@
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-  }
+}
+
+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", false);
-    test(S(""), "abcdefghij", false);
-    test(S(""), "abcdefghijklmnopqrst", false);
-    test(S("abcde"), "", true);
-    test(S("abcde"), "abcde", false);
-    test(S("abcde"), "abcdefghij", false);
-    test(S("abcde"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghij"), "", true);
-    test(S("abcdefghij"), "abcde", true);
-    test(S("abcdefghij"), "abcdefghij", false);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghijklmnopqrst"), "", true);
-    test(S("abcdefghijklmnopqrst"), "abcde", true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
@@ -25,9 +25,8 @@
     assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), S(""), false);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
@@ -44,27 +43,12 @@
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+}
+
+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"), false);
-    test(S(""), S("abcdefghij"), false);
-    test(S(""), S("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), S(""), true);
-    test(S("abcde"), S("abcde"), false);
-    test(S("abcde"), S("abcdefghij"), false);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), S(""), true);
-    test(S("abcdefghij"), S("abcde"), true);
-    test(S("abcdefghij"), S("abcdefghij"), false);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), S(""), true);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
@@ -43,28 +43,12 @@
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(S(""), SV(""), false);
-    test(S(""), SV("abcde"), false);
-    test(S(""), SV("abcdefghij"), false);
-    test(S(""), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), SV(""), true);
-    test(S("abcde"), SV("abcde"), false);
-    test(S("abcde"), SV("abcdefghij"), false);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), SV(""), true);
-    test(S("abcdefghij"), SV("abcde"), true);
-    test(S("abcdefghij"), SV("abcdefghij"), false);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), SV(""), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
@@ -43,28 +43,12 @@
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string     <char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(SV(""), S(""), false);
-    test(SV(""), S("abcde"), false);
-    test(SV(""), S("abcdefghij"), false);
-    test(SV(""), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcde"), S(""), true);
-    test(SV("abcde"), S("abcde"), false);
-    test(SV("abcde"), S("abcdefghij"), false);
-    test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcdefghij"), S(""), true);
-    test(SV("abcdefghij"), S("abcde"), true);
-    test(SV("abcdefghij"), S("abcdefghij"), false);
-    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcdefghijklmnopqrst"), S(""), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test("", S(""), true);
     test("", S("abcde"), false);
     test("", S("abcdefghij"), false);
@@ -43,27 +42,12 @@
     test("abcdefghijklmnopqrst", S("abcde"), true);
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+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(""), true);
-    test("", S("abcde"), false);
-    test("", S("abcdefghij"), false);
-    test("", S("abcdefghijklmnopqrst"), false);
-    test("abcde", S(""), true);
-    test("abcde", S("abcde"), true);
-    test("abcde", S("abcdefghij"), false);
-    test("abcde", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghij", S(""), true);
-    test("abcdefghij", S("abcde"), true);
-    test("abcdefghij", S("abcdefghij"), true);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), false);
-    test("abcdefghijklmnopqrst", S(""), true);
-    test("abcdefghijklmnopqrst", S("abcde"), true);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), true);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), "", true);
     test(S(""), "abcde", false);
     test(S(""), "abcdefghij", false);
@@ -43,27 +42,12 @@
     test(S("abcdefghijklmnopqrst"), "abcde", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-  }
+}
+
+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(""), "", true);
-    test(S(""), "abcde", false);
-    test(S(""), "abcdefghij", false);
-    test(S(""), "abcdefghijklmnopqrst", false);
-    test(S("abcde"), "", true);
-    test(S("abcde"), "abcde", true);
-    test(S("abcde"), "abcdefghij", false);
-    test(S("abcde"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghij"), "", true);
-    test(S("abcdefghij"), "abcde", true);
-    test(S("abcdefghij"), "abcdefghij", true);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
-    test(S("abcdefghijklmnopqrst"), "", true);
-    test(S("abcdefghijklmnopqrst"), "abcde", true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
@@ -25,9 +25,8 @@
     assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), S(""), true);
     test(S(""), S("abcde"), false);
     test(S(""), S("abcdefghij"), false);
@@ -44,27 +43,12 @@
     test(S("abcdefghijklmnopqrst"), S("abcde"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+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(""), true);
-    test(S(""), S("abcde"), false);
-    test(S(""), S("abcdefghij"), false);
-    test(S(""), S("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), S(""), true);
-    test(S("abcde"), S("abcde"), true);
-    test(S("abcde"), S("abcdefghij"), false);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), S(""), true);
-    test(S("abcdefghij"), S("abcde"), true);
-    test(S("abcdefghij"), S("abcdefghij"), true);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), S(""), true);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), false);
     test(S(""), SV("abcdefghij"), false);
@@ -43,28 +43,12 @@
     test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(S(""), SV(""), true);
-    test(S(""), SV("abcde"), false);
-    test(S(""), SV("abcdefghij"), false);
-    test(S(""), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), SV(""), true);
-    test(S("abcde"), SV("abcde"), true);
-    test(S("abcde"), SV("abcdefghij"), false);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), SV(""), true);
-    test(S("abcdefghij"), SV("abcde"), true);
-    test(S("abcdefghij"), SV("abcdefghij"), true);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), SV(""), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), false);
     test(SV(""), S("abcdefghij"), false);
@@ -43,28 +43,12 @@
     test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(SV(""), S(""), true);
-    test(SV(""), S("abcde"), false);
-    test(SV(""), S("abcdefghij"), false);
-    test(SV(""), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcde"), S(""), true);
-    test(SV("abcde"), S("abcde"), true);
-    test(SV("abcde"), S("abcdefghij"), false);
-    test(SV("abcde"), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcdefghij"), S(""), true);
-    test(SV("abcdefghij"), S("abcde"), true);
-    test(SV("abcdefghij"), S("abcdefghij"), true);
-    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), false);
-    test(SV("abcdefghijklmnopqrst"), S(""), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs < rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test("", S(""), false);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
@@ -43,27 +42,12 @@
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-  }
+}
+
+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(""), false);
-    test("abcde", S("abcde"), false);
-    test("abcde", S("abcdefghij"), true);
-    test("abcde", S("abcdefghijklmnopqrst"), true);
-    test("abcdefghij", S(""), false);
-    test("abcdefghij", S("abcde"), false);
-    test("abcdefghij", S("abcdefghij"), false);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), true);
-    test("abcdefghijklmnopqrst", S(""), false);
-    test("abcdefghijklmnopqrst", S("abcde"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs < rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), "", false);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
@@ -43,27 +42,12 @@
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-  }
+}
+
+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"), "", false);
-    test(S("abcde"), "abcde", false);
-    test(S("abcde"), "abcdefghij", true);
-    test(S("abcde"), "abcdefghijklmnopqrst", true);
-    test(S("abcdefghij"), "", false);
-    test(S("abcdefghij"), "abcde", false);
-    test(S("abcdefghij"), "abcdefghij", false);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
-    test(S("abcdefghijklmnopqrst"), "", false);
-    test(S("abcdefghijklmnopqrst"), "abcde", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
@@ -25,9 +25,8 @@
     assert((lhs < rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), S(""), false);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
@@ -44,27 +43,12 @@
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+}
+
+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(""), false);
-    test(S("abcde"), S("abcde"), false);
-    test(S("abcde"), S("abcdefghij"), true);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), S(""), false);
-    test(S("abcdefghij"), S("abcde"), false);
-    test(S("abcdefghij"), S("abcdefghij"), false);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), S(""), false);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs < rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(S(""), SV(""), false);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
@@ -43,28 +43,12 @@
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(S(""), SV(""), false);
-    test(S(""), SV("abcde"), true);
-    test(S(""), SV("abcdefghij"), true);
-    test(S(""), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), SV(""), false);
-    test(S("abcde"), SV("abcde"), false);
-    test(S("abcde"), SV("abcdefghij"), true);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), SV(""), false);
-    test(S("abcdefghij"), SV("abcde"), false);
-    test(S("abcdefghij"), SV("abcdefghij"), false);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), SV(""), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs < rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(SV(""), S(""), false);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
@@ -43,28 +43,12 @@
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(SV(""), S(""), false);
-    test(SV(""), S("abcde"), true);
-    test(SV(""), S("abcdefghij"), true);
-    test(SV(""), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcde"), S(""), false);
-    test(SV("abcde"), S("abcde"), false);
-    test(SV("abcde"), S("abcdefghij"), true);
-    test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghij"), S(""), false);
-    test(SV("abcdefghij"), S("abcde"), false);
-    test(SV("abcdefghij"), S("abcdefghij"), false);
-    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghijklmnopqrst"), S(""), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test("", S(""), true);
     test("", S("abcde"), true);
     test("", S("abcdefghij"), true);
@@ -43,27 +42,12 @@
     test("abcdefghijklmnopqrst", S("abcde"), false);
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+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(""), true);
-    test("", S("abcde"), true);
-    test("", S("abcdefghij"), true);
-    test("", S("abcdefghijklmnopqrst"), true);
-    test("abcde", S(""), false);
-    test("abcde", S("abcde"), true);
-    test("abcde", S("abcdefghij"), true);
-    test("abcde", S("abcdefghijklmnopqrst"), true);
-    test("abcdefghij", S(""), false);
-    test("abcdefghij", S("abcde"), false);
-    test("abcdefghij", S("abcdefghij"), true);
-    test("abcdefghij", S("abcdefghijklmnopqrst"), true);
-    test("abcdefghijklmnopqrst", S(""), false);
-    test("abcdefghijklmnopqrst", S("abcde"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghij"), false);
-    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
@@ -24,9 +24,8 @@
     assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), "", true);
     test(S(""), "abcde", true);
     test(S(""), "abcdefghij", true);
@@ -43,27 +42,12 @@
     test(S("abcdefghijklmnopqrst"), "abcde", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-  }
+}
+
+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(""), "", true);
-    test(S(""), "abcde", true);
-    test(S(""), "abcdefghij", true);
-    test(S(""), "abcdefghijklmnopqrst", true);
-    test(S("abcde"), "", false);
-    test(S("abcde"), "abcde", true);
-    test(S("abcde"), "abcdefghij", true);
-    test(S("abcde"), "abcdefghijklmnopqrst", true);
-    test(S("abcdefghij"), "", false);
-    test(S("abcdefghij"), "abcde", false);
-    test(S("abcdefghij"), "abcdefghij", true);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
-    test(S("abcdefghijklmnopqrst"), "", false);
-    test(S("abcdefghijklmnopqrst"), "abcde", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
@@ -25,9 +25,8 @@
     assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), S(""), true);
     test(S(""), S("abcde"), true);
     test(S(""), S("abcdefghij"), true);
@@ -44,27 +43,12 @@
     test(S("abcdefghijklmnopqrst"), S("abcde"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+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(""), true);
-    test(S(""), S("abcde"), true);
-    test(S(""), S("abcdefghij"), true);
-    test(S(""), S("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), S(""), false);
-    test(S("abcde"), S("abcde"), true);
-    test(S("abcde"), S("abcdefghij"), true);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), S(""), false);
-    test(S("abcdefghij"), S("abcde"), false);
-    test(S("abcdefghij"), S("abcdefghij"), true);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), S(""), false);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(S(""), SV(""), true);
     test(S(""), SV("abcde"), true);
     test(S(""), SV("abcdefghij"), true);
@@ -43,28 +43,12 @@
     test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(S(""), SV(""), true);
-    test(S(""), SV("abcde"), true);
-    test(S(""), SV("abcdefghij"), true);
-    test(S(""), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), SV(""), false);
-    test(S("abcde"), SV("abcde"), true);
-    test(S("abcde"), SV("abcdefghij"), true);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), SV(""), false);
-    test(S("abcdefghij"), SV("abcde"), false);
-    test(S("abcdefghij"), SV("abcdefghij"), true);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), SV(""), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
@@ -23,10 +23,10 @@
     assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test(SV(""), S(""), true);
     test(SV(""), S("abcde"), true);
     test(SV(""), S("abcdefghij"), true);
@@ -43,28 +43,12 @@
     test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
-    test(SV(""), S(""), true);
-    test(SV(""), S("abcde"), true);
-    test(SV(""), S("abcdefghij"), true);
-    test(SV(""), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcde"), S(""), false);
-    test(SV("abcde"), S("abcde"), true);
-    test(SV("abcde"), S("abcdefghij"), true);
-    test(SV("abcde"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghij"), S(""), false);
-    test(SV("abcdefghij"), S("abcde"), false);
-    test(SV("abcdefghij"), S("abcdefghij"), true);
-    test(SV("abcdefghij"), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcdefghijklmnopqrst"), S(""), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcde"), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
-    test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
@@ -31,22 +31,18 @@
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""));
     test(S("abcde"));
     test(S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"));
-  }
+}
+
+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("abcde"));
-    test(S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"));
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
@@ -47,32 +47,31 @@
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test_const(S(""));
-    test_const(S("abcde"));
-    test_const(S("abcdefghij"));
-    test_const(S("abcdefghijklmnopqrst"));
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test_const(S(""));
     test_const(S("abcde"));
     test_const(S("abcdefghij"));
     test_const(S("abcdefghijklmnopqrst"));
-  }
-#endif
 #if TEST_STD_VER > 14
   {
-    typedef std::string S;
-    S s1("");                     test_nonconst(s1);
-    S s2("abcde");                test_nonconst(s2);
-    S s3("abcdefghij");           test_nonconst(s3);
-    S s4("abcdefghijklmnopqrst"); test_nonconst(s4);
+        S s1("");
+        test_nonconst(s1);
+        S s2("abcde");
+        test_nonconst(s2);
+        S s3("abcdefghij");
+        test_nonconst(s3);
+        S s4("abcdefghijklmnopqrst");
+        test_nonconst(s4);
   }
 #endif
+}
+
+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;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
@@ -24,24 +24,31 @@
     assert(s.get_allocator() == a);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using A = test_allocator<char>;
+    using S = std::basic_string<char, std::char_traits<char>, A>;
+    test(S(""), A());
+    test(S("abcde", A()), A());
+    test(S("abcdefghij", A()), A());
+    test(S("abcdefghijklmnopqrst", A()), A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+    using A = test_allocator<char>;
+    using S = std::basic_string<char, std::char_traits<char>, A>;
     test(S(""), A());
     test(S("abcde", A(1)), A(1));
     test(S("abcdefghij", A(2)), A(2));
     test(S("abcdefghijklmnopqrst", A(3)), A(3));
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
+    test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(""), A());
-    test(S("abcde", A()), A());
-    test(S("abcdefghij", A()), A());
-    test(S("abcdefghijklmnopqrst", A()), A());
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
@@ -33,9 +33,8 @@
     assert(sign(s.compare(str)) == sign(x));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), "", 0);
     test(S(""), "abcde", -5);
     test(S(""), "abcdefghij", -10);
@@ -52,27 +51,12 @@
     test(S("abcdefghijklmnopqrst"), "abcde", 15);
     test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
-  }
+}
+
+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(""), "abcde", -5);
-    test(S(""), "abcdefghij", -10);
-    test(S(""), "abcdefghijklmnopqrst", -20);
-    test(S("abcde"), "", 5);
-    test(S("abcde"), "abcde", 0);
-    test(S("abcde"), "abcdefghij", -5);
-    test(S("abcde"), "abcdefghijklmnopqrst", -15);
-    test(S("abcdefghij"), "", 10);
-    test(S("abcdefghij"), "abcde", 5);
-    test(S("abcdefghij"), "abcdefghij", 0);
-    test(S("abcdefghij"), "abcdefghijklmnopqrst", -10);
-    test(S("abcdefghijklmnopqrst"), "", 20);
-    test(S("abcdefghijklmnopqrst"), "abcde", 15);
-    test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
-    test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
@@ -5979,8 +5979,11 @@
   return true;
 }
 
-template <class S, class SV>
+template <class CharT, template <class> class Alloc>
 void test() {
+  using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+
   test0<S, SV>();
   test1<S, SV>();
   test2<S, SV>();
@@ -6102,10 +6105,9 @@
 
 int main(int, char**)
 {
-  test<std::string, std::string_view>();
+  test<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>,
-       std::basic_string_view<char, std::char_traits<char>>>();
+  test<char, min_allocator>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -361,20 +361,17 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
     test2<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -1353,7 +1353,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -50,8 +50,7 @@
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test0()
-{
+TEST_CONSTEXPR_CXX20 bool test0() {
     test(S(""), 0, 0, S(""), 0);
     test(S(""), 0, 0, S("abcde"), -5);
     test(S(""), 0, 0, S("abcdefghij"), -10);
@@ -152,11 +151,11 @@
     test(S("abcde"), 5, 1, S("abcde"), -5);
     test(S("abcde"), 5, 1, S("abcdefghij"), -10);
     test(S("abcde"), 5, 1, S("abcdefghijklmnopqrst"), -20);
+    return true;
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test1()
-{
+TEST_CONSTEXPR_CXX20 bool test1() {
     test(S("abcde"), 6, 0, S(""), 0);
     test(S("abcde"), 6, 0, S("abcde"), 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 0);
@@ -257,11 +256,11 @@
     test(S("abcdefghij"), 11, 0, S("abcde"), 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghij"), 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 0);
+    return true;
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test2()
-{
+TEST_CONSTEXPR_CXX20 bool test2() {
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), -5);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcdefghij"), -10);
@@ -358,39 +357,30 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcde"), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghij"), 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 0);
+    return true;
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+void test() {
     test0<S>();
     test1<S>();
     test2<S>();
-  }
-#endif
 
-#if TEST_STD_VER >= 11
-  { // LWG 2946
-    std::string s = " !";
-    assert(s.compare(0, 1, {"abc", 1}) < 0);
-  }
+#if TEST_STD_VER > 17
+    static_assert(test0<S>());
+    static_assert(test1<S>());
+    static_assert(test2<S>());
 #endif
-
-  return true;
 }
 
-int main(int, char**)
-{
-  test();
-#if TEST_STD_VER > 17
-  static_assert(test());
+int main(int, char**) {
+    test<std::string>();
+#if TEST_STD_VER >= 11
+    test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    { // LWG 2946
+        std::string s = " !";
+        assert(s.compare(0, 1, {"abc", 1}) < 0);
+    }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -6071,7 +6071,7 @@
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -361,22 +361,20 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
@@ -33,29 +33,8 @@
     assert(sign(s.compare(str)) == sign(x));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), S(""), 0);
-    test(S(""), S("abcde"), -5);
-    test(S(""), S("abcdefghij"), -10);
-    test(S(""), S("abcdefghijklmnopqrst"), -20);
-    test(S("abcde"), S(""), 5);
-    test(S("abcde"), S("abcde"), 0);
-    test(S("abcde"), S("abcdefghij"), -5);
-    test(S("abcde"), S("abcdefghijklmnopqrst"), -15);
-    test(S("abcdefghij"), S(""), 10);
-    test(S("abcdefghij"), S("abcde"), 5);
-    test(S("abcdefghij"), S("abcdefghij"), 0);
-    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), -10);
-    test(S("abcdefghijklmnopqrst"), S(""), 20);
-    test(S("abcdefghijklmnopqrst"), S("abcde"), 15);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
-    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 0);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), -5);
     test(S(""), S("abcdefghij"), -10);
@@ -72,14 +51,16 @@
     test(S("abcdefghijklmnopqrst"), S("abcde"), 15);
     test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 0);
-  }
-#endif
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<std::string>();
 #if TEST_STD_VER >= 11
-  { // LWG 2946
-    std::string s = " !";
-    assert(s.compare({"abc", 1}) < 0);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    { // LWG 2946
+        std::string s = " !";
+        assert(s.compare({"abc", 1}) < 0);
+    }
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
@@ -33,10 +33,11 @@
     assert(sign(s.compare(sv)) == sign(x));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+
     test(S(""), SV(""), 0);
     test(S(""), SV("abcde"), -5);
     test(S(""), SV("abcdefghij"), -10);
@@ -53,28 +54,12 @@
     test(S("abcdefghijklmnopqrst"), SV("abcde"), 15);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test(S(""), SV(""), 0);
-    test(S(""), SV("abcde"), -5);
-    test(S(""), SV("abcdefghij"), -10);
-    test(S(""), SV("abcdefghijklmnopqrst"), -20);
-    test(S("abcde"), SV(""), 5);
-    test(S("abcde"), SV("abcde"), 0);
-    test(S("abcde"), SV("abcdefghij"), -5);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), -15);
-    test(S("abcdefghij"), SV(""), 10);
-    test(S("abcdefghij"), SV("abcde"), 5);
-    test(S("abcdefghij"), SV("abcdefghij"), 0);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), -10);
-    test(S("abcdefghijklmnopqrst"), SV(""), 20);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), 15);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
@@ -37,9 +37,8 @@
         assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), 'q', 0, S::npos);
     test(S(""), 'q', 1, S::npos);
     test(S("kitcj"), 'q', 0, 0);
@@ -67,38 +66,12 @@
     test(S("csope"), 'q', 0);
     test(S("gfsmthlkon"), 'q', 0);
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), 'q', 0, S::npos);
-    test(S(""), 'q', 1, S::npos);
-    test(S("kitcj"), 'q', 0, 0);
-    test(S("qkamf"), 'q', 1, 1);
-    test(S("nhmko"), 'q', 2, 2);
-    test(S("tpsaf"), 'q', 4, 4);
-    test(S("lahfb"), 'q', 5, S::npos);
-    test(S("irkhs"), 'q', 6, S::npos);
-    test(S("gmfhdaipsr"), 'q', 0, 0);
-    test(S("kantesmpgj"), 'q', 1, 1);
-    test(S("odaftiegpm"), 'q', 5, 5);
-    test(S("oknlrstdpi"), 'q', 9, 9);
-    test(S("eolhfgpjqk"), 'q', 10, S::npos);
-    test(S("pcdrofikas"), 'q', 11, S::npos);
-    test(S("nbatdlmekrgcfqsophij"), 'q', 0, 0);
-    test(S("bnrpehidofmqtcksjgla"), 'q', 1, 1);
-    test(S("jdmciepkaqgotsrfnhlb"), 'q', 10, 10);
-    test(S("jtdaefblsokrmhpgcnqi"), 'q', 19, 19);
-    test(S("hkbgspofltajcnedqmri"), 'q', 20, S::npos);
-    test(S("oselktgbcapndfjihrmq"), 'q', 21, S::npos);
+}
 
-    test(S(""), 'q', S::npos);
-    test(S("q"), 'q', S::npos);
-    test(S("qqq"), 'q', S::npos);
-    test(S("csope"), 'q', 0);
-    test(S("gfsmthlkon"), 'q', 0);
-    test(S("laenfsbridchgotmkqpj"), 'q', 0);
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
@@ -142,18 +142,16 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
@@ -367,22 +367,18 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
@@ -142,25 +142,20 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
-#endif
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<std::string>();
 #if TEST_STD_VER >= 11
-  { // LWG 2946
-    std::string s = " !";
-    assert(s.find_first_not_of({"abc", 1}) == 0);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    { // LWG 2946
+        std::string s = " !";
+        assert(s.find_first_not_of({"abc", 1}) == 0);
+    }
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
@@ -142,20 +142,19 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+
     test0<S, SV>();
     test1<S, SV>();
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
@@ -37,9 +37,8 @@
         assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), 'e', 0, S::npos);
     test(S(""), 'e', 1, S::npos);
     test(S("kitcj"), 'e', 0, S::npos);
@@ -65,36 +64,12 @@
     test(S("csope"), 'e', 4);
     test(S("gfsmthlkon"), 'e', S::npos);
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), 'e', 0, S::npos);
-    test(S(""), 'e', 1, S::npos);
-    test(S("kitcj"), 'e', 0, S::npos);
-    test(S("qkamf"), 'e', 1, S::npos);
-    test(S("nhmko"), 'e', 2, S::npos);
-    test(S("tpsaf"), 'e', 4, S::npos);
-    test(S("lahfb"), 'e', 5, S::npos);
-    test(S("irkhs"), 'e', 6, S::npos);
-    test(S("gmfhdaipsr"), 'e', 0, S::npos);
-    test(S("kantesmpgj"), 'e', 1, 4);
-    test(S("odaftiegpm"), 'e', 5, 6);
-    test(S("oknlrstdpi"), 'e', 9, S::npos);
-    test(S("eolhfgpjqk"), 'e', 10, S::npos);
-    test(S("pcdrofikas"), 'e', 11, S::npos);
-    test(S("nbatdlmekrgcfqsophij"), 'e', 0, 7);
-    test(S("bnrpehidofmqtcksjgla"), 'e', 1, 4);
-    test(S("jdmciepkaqgotsrfnhlb"), 'e', 10, S::npos);
-    test(S("jtdaefblsokrmhpgcnqi"), 'e', 19, S::npos);
-    test(S("hkbgspofltajcnedqmri"), 'e', 20, S::npos);
-    test(S("oselktgbcapndfjihrmq"), 'e', 21, S::npos);
+}
 
-    test(S(""), 'e', S::npos);
-    test(S("csope"), 'e', 4);
-    test(S("gfsmthlkon"), 'e', S::npos);
-    test(S("laenfsbridchgotmkqpj"), 'e', 2);
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
@@ -143,18 +143,16 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
@@ -367,22 +367,18 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
@@ -142,25 +142,20 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
-#endif
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<std::string>();
 #if TEST_STD_VER >= 11
-  { // LWG 2946
-    std::string s = " !";
-    assert(s.find_first_of({"abc", 1}) == std::string::npos);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    { // LWG 2946
+        std::string s = " !";
+        assert(s.find_first_of({"abc", 1}) == std::string::npos);
+    }
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
@@ -142,20 +142,19 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+
     test0<S, SV>();
     test1<S, SV>();
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
@@ -37,9 +37,8 @@
         assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), 'i', 0, S::npos);
     test(S(""), 'i', 1, S::npos);
     test(S("kitcj"), 'i', 0, 0);
@@ -65,36 +64,12 @@
     test(S("csope"), 'i', 4);
     test(S("gfsmthlkon"), 'i', 9);
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), 'i', 0, S::npos);
-    test(S(""), 'i', 1, S::npos);
-    test(S("kitcj"), 'i', 0, 0);
-    test(S("qkamf"), 'i', 1, 1);
-    test(S("nhmko"), 'i', 2, 2);
-    test(S("tpsaf"), 'i', 4, 4);
-    test(S("lahfb"), 'i', 5, 4);
-    test(S("irkhs"), 'i', 6, 4);
-    test(S("gmfhdaipsr"), 'i', 0, 0);
-    test(S("kantesmpgj"), 'i', 1, 1);
-    test(S("odaftiegpm"), 'i', 5, 4);
-    test(S("oknlrstdpi"), 'i', 9, 8);
-    test(S("eolhfgpjqk"), 'i', 10, 9);
-    test(S("pcdrofikas"), 'i', 11, 9);
-    test(S("nbatdlmekrgcfqsophij"), 'i', 0, 0);
-    test(S("bnrpehidofmqtcksjgla"), 'i', 1, 1);
-    test(S("jdmciepkaqgotsrfnhlb"), 'i', 10, 10);
-    test(S("jtdaefblsokrmhpgcnqi"), 'i', 19, 18);
-    test(S("hkbgspofltajcnedqmri"), 'i', 20, 18);
-    test(S("oselktgbcapndfjihrmq"), 'i', 21, 19);
+}
 
-    test(S(""), 'i', S::npos);
-    test(S("csope"), 'i', 4);
-    test(S("gfsmthlkon"), 'i', 9);
-    test(S("laenfsbridchgotmkqpj"), 'i', 19);
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
@@ -143,18 +143,16 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
@@ -367,22 +367,18 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
@@ -142,25 +142,20 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
-#endif
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<std::string>();
 #if TEST_STD_VER >= 11
-  { // LWG 2946
-    std::string s = " !";
-    assert(s.find_last_not_of({"abc", 1}) == s.size() - 1);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    { // LWG 2946
+        std::string s = " !";
+        assert(s.find_last_not_of({"abc", 1}) == s.size() - 1);
+    }
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
@@ -142,20 +142,19 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
+
     test0<S, SV>();
     test1<S, SV>();
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-     typedef std::string_view SV;
-     test0<S, SV>();
-     test1<S, SV>();
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
@@ -37,9 +37,8 @@
         assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), 'm', 0, S::npos);
     test(S(""), 'm', 1, S::npos);
     test(S("kitcj"), 'm', 0, S::npos);
@@ -65,36 +64,12 @@
     test(S("csope"), 'm', S::npos);
     test(S("gfsmthlkon"), 'm', 3);
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), 'm', 0, S::npos);
-    test(S(""), 'm', 1, S::npos);
-    test(S("kitcj"), 'm', 0, S::npos);
-    test(S("qkamf"), 'm', 1, S::npos);
-    test(S("nhmko"), 'm', 2, 2);
-    test(S("tpsaf"), 'm', 4, S::npos);
-    test(S("lahfb"), 'm', 5, S::npos);
-    test(S("irkhs"), 'm', 6, S::npos);
-    test(S("gmfhdaipsr"), 'm', 0, S::npos);
-    test(S("kantesmpgj"), 'm', 1, S::npos);
-    test(S("odaftiegpm"), 'm', 5, S::npos);
-    test(S("oknlrstdpi"), 'm', 9, S::npos);
-    test(S("eolhfgpjqk"), 'm', 10, S::npos);
-    test(S("pcdrofikas"), 'm', 11, S::npos);
-    test(S("nbatdlmekrgcfqsophij"), 'm', 0, S::npos);
-    test(S("bnrpehidofmqtcksjgla"), 'm', 1, S::npos);
-    test(S("jdmciepkaqgotsrfnhlb"), 'm', 10, 2);
-    test(S("jtdaefblsokrmhpgcnqi"), 'm', 19, 12);
-    test(S("hkbgspofltajcnedqmri"), 'm', 20, 17);
-    test(S("oselktgbcapndfjihrmq"), 'm', 21, 18);
+}
 
-    test(S(""), 'm', S::npos);
-    test(S("csope"), 'm', S::npos);
-    test(S("gfsmthlkon"), 'm', 3);
-    test(S("laenfsbridchgotmkqpj"), 'm', 15);
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
@@ -143,18 +143,16 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
@@ -367,22 +367,18 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
@@ -142,25 +142,20 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 19);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
-#endif
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<std::string>();
 #if TEST_STD_VER >= 11
-  { // LWG 2946
-    std::string s = " !";
-    assert(s.find_last_of({"abc", 1}) == std::string::npos);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    { // LWG 2946
+        std::string s = " !";
+        assert(s.find_last_of({"abc", 1}) == std::string::npos);
+    }
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
@@ -142,20 +142,18 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 19);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test0<S, SV>();
     test1<S, SV>();
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
@@ -37,9 +37,8 @@
         assert(0 <= x && x + 1 <= s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), 'c', 0, S::npos);
     test(S(""), 'c', 1, S::npos);
     test(S("abcde"), 'c', 0, 2);
@@ -65,36 +64,12 @@
     test(S("abcde"), 'c', 2);
     test(S("abcdeabcde"), 'c', 2);
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), 'c', 0, S::npos);
-    test(S(""), 'c', 1, S::npos);
-    test(S("abcde"), 'c', 0, 2);
-    test(S("abcde"), 'c', 1, 2);
-    test(S("abcde"), 'c', 2, 2);
-    test(S("abcde"), 'c', 4, S::npos);
-    test(S("abcde"), 'c', 5, S::npos);
-    test(S("abcde"), 'c', 6, S::npos);
-    test(S("abcdeabcde"), 'c', 0, 2);
-    test(S("abcdeabcde"), 'c', 1, 2);
-    test(S("abcdeabcde"), 'c', 5, 7);
-    test(S("abcdeabcde"), 'c', 9, S::npos);
-    test(S("abcdeabcde"), 'c', 10, S::npos);
-    test(S("abcdeabcde"), 'c', 11, S::npos);
-    test(S("abcdeabcdeabcdeabcde"), 'c', 0, 2);
-    test(S("abcdeabcdeabcdeabcde"), 'c', 1, 2);
-    test(S("abcdeabcdeabcdeabcde"), 'c', 10, 12);
-    test(S("abcdeabcdeabcdeabcde"), 'c', 19, S::npos);
-    test(S("abcdeabcdeabcdeabcde"), 'c', 20, S::npos);
-    test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos);
+}
 
-    test(S(""), 'c', S::npos);
-    test(S("abcde"), 'c', 2);
-    test(S("abcdeabcde"), 'c', 2);
-    test(S("abcdeabcdeabcdeabcde"), 'c', 2);
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
@@ -149,18 +149,16 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
@@ -367,22 +367,18 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
@@ -142,20 +142,17 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
-
 #if TEST_STD_VER >= 11
   { // LWG 2946
     std::string s = " !";
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
@@ -142,20 +142,18 @@
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test0<S, SV>();
     test1<S, SV>();
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
@@ -37,9 +37,8 @@
         assert(x + 1 <= s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test(S(""), 'b', 0, S::npos);
     test(S(""), 'b', 1, S::npos);
     test(S("abcde"), 'b', 0, S::npos);
@@ -65,36 +64,12 @@
     test(S("abcde"), 'b', 1);
     test(S("abcdeabcde"), 'b', 6);
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), 'b', 0, S::npos);
-    test(S(""), 'b', 1, S::npos);
-    test(S("abcde"), 'b', 0, S::npos);
-    test(S("abcde"), 'b', 1, 1);
-    test(S("abcde"), 'b', 2, 1);
-    test(S("abcde"), 'b', 4, 1);
-    test(S("abcde"), 'b', 5, 1);
-    test(S("abcde"), 'b', 6, 1);
-    test(S("abcdeabcde"), 'b', 0, S::npos);
-    test(S("abcdeabcde"), 'b', 1, 1);
-    test(S("abcdeabcde"), 'b', 5, 1);
-    test(S("abcdeabcde"), 'b', 9, 6);
-    test(S("abcdeabcde"), 'b', 10, 6);
-    test(S("abcdeabcde"), 'b', 11, 6);
-    test(S("abcdeabcdeabcdeabcde"), 'b', 0, S::npos);
-    test(S("abcdeabcdeabcdeabcde"), 'b', 1, 1);
-    test(S("abcdeabcdeabcdeabcde"), 'b', 10, 6);
-    test(S("abcdeabcdeabcdeabcde"), 'b', 19, 16);
-    test(S("abcdeabcdeabcdeabcde"), 'b', 20, 16);
-    test(S("abcdeabcdeabcdeabcde"), 'b', 21, 16);
+}
 
-    test(S(""), 'b', S::npos);
-    test(S("abcde"), 'b', 1);
-    test(S("abcdeabcde"), 'b', 6);
-    test(S("abcdeabcdeabcdeabcde"), 'b', 16);
-  }
+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;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
@@ -150,18 +150,16 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
@@ -367,22 +367,18 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
-  }
+}
+
+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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
@@ -142,25 +142,20 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
     test0<S>();
     test1<S>();
-  }
-#endif
+}
 
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<std::string>();
 #if TEST_STD_VER >= 11
-  { // LWG 2946
-    std::string s = " !";
-    assert(s.rfind({"abc", 1}) == std::string::npos);
-  }
+    test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    { // LWG 2946
+        std::string s = " !";
+        assert(s.rfind({"abc", 1}) == std::string::npos);
+    }
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
@@ -142,20 +142,18 @@
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+    using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
     test0<S, SV>();
     test1<S, SV>();
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
@@ -114,7 +114,7 @@
 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp b/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
@@ -25,29 +25,38 @@
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+    typedef Alloc<CharT> A;
+    typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> > S;
+    test_contiguous(S(A()));
+    test_contiguous(S("1", A()));
+    test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, std::allocator>() {
+    typedef std::allocator<char> A;
+    typedef std::basic_string<char, std::char_traits<char>, A> S;
     test_contiguous(S());
     test_contiguous(S("1"));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890"));
-  }
+}
 
-  {
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test_contiguous(S(A(3)));
     test_contiguous(S("1", A(5)));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test_string<char, std::allocator>();
+    test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test_contiguous(S(A{}));
-    test_contiguous(S("1", A()));
-    test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-  }
+    test_string<char, min_allocator>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
@@ -16,19 +16,21 @@
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    S  s1 {};
-    S  s2 { "abcde", 5 };
-
-    ASSERT_NOEXCEPT(s1.starts_with('e'));
-
-    assert (!s1.starts_with('a'));
-    assert (!s1.starts_with('x'));
-    assert ( s2.starts_with('a'));
-    assert (!s2.starts_with('x'));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s1{};
+  S s2{"abcde", 5};
+
+  ASSERT_NOEXCEPT(s1.starts_with('e'));
+
+  assert(!s1.starts_with('a'));
+  assert(!s1.starts_with('x'));
+  assert(s2.starts_with('a'));
+  assert(!s2.starts_with('x'));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 
   return true;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
@@ -16,47 +16,49 @@
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    const char *s = "abcde";
-    S  s0 {};
-    S  s1 { s, 1 };
-    S  s2 { s, 2 };
-//     S  s3 { s, 3 };
-//     S  s4 { s, 4 };
-//     S  s5 { s, 5 };
-    S  sNot {"def", 3 };
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  const char* s = "abcde";
+  S s0{};
+  S s1{s, 1};
+  S s2{s, 2};
+  //     S  s3 { s, 3 };
+  //     S  s4 { s, 4 };
+  //     S  s5 { s, 5 };
+  S sNot{"def", 3};
 
-    LIBCPP_ASSERT_NOEXCEPT(s0.starts_with(""));
+  LIBCPP_ASSERT_NOEXCEPT(s0.starts_with(""));
 
-    assert ( s0.starts_with(""));
-    assert (!s0.starts_with("a"));
+  assert(s0.starts_with(""));
+  assert(!s0.starts_with("a"));
 
-    assert ( s1.starts_with(""));
-    assert ( s1.starts_with("a"));
-    assert (!s1.starts_with("ab"));
-    assert (!s1.starts_with("abc"));
-    assert (!s1.starts_with("abcd"));
-    assert (!s1.starts_with("abcde"));
-    assert (!s1.starts_with("def"));
+  assert(s1.starts_with(""));
+  assert(s1.starts_with("a"));
+  assert(!s1.starts_with("ab"));
+  assert(!s1.starts_with("abc"));
+  assert(!s1.starts_with("abcd"));
+  assert(!s1.starts_with("abcde"));
+  assert(!s1.starts_with("def"));
 
-    assert ( s2.starts_with(""));
-    assert ( s2.starts_with("a"));
-    assert ( s2.starts_with("ab"));
-    assert (!s2.starts_with("abc"));
-    assert (!s2.starts_with("abcd"));
-    assert (!s2.starts_with("abcde"));
-    assert (!s2.starts_with("def"));
+  assert(s2.starts_with(""));
+  assert(s2.starts_with("a"));
+  assert(s2.starts_with("ab"));
+  assert(!s2.starts_with("abc"));
+  assert(!s2.starts_with("abcd"));
+  assert(!s2.starts_with("abcde"));
+  assert(!s2.starts_with("def"));
 
-    assert ( sNot.starts_with(""));
-    assert (!sNot.starts_with("a"));
-    assert (!sNot.starts_with("ab"));
-    assert (!sNot.starts_with("abc"));
-    assert (!sNot.starts_with("abcd"));
-    assert (!sNot.starts_with("abcde"));
-    assert ( sNot.starts_with("def"));
-  }
+  assert(sNot.starts_with(""));
+  assert(!sNot.starts_with("a"));
+  assert(!sNot.starts_with("ab"));
+  assert(!sNot.starts_with("abc"));
+  assert(!sNot.starts_with("abcd"));
+  assert(!sNot.starts_with("abcde"));
+  assert(sNot.starts_with("def"));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 
   return true;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
@@ -16,57 +16,62 @@
 
 #include "test_macros.h"
 
-constexpr bool test() {
-    typedef std::string S;
-    typedef std::string_view SV;
-    const char *s = "abcde";
-
-    S   s0;
-    S   s1  { s, 1 };
-    S   s2  { s, 2 };
-//  S   s3  { s, 3 };
-//  S   s4  { s, 4 };
-//  S   s5  { s, 5 };
-    S  sNot { "def", 3 };
-
-    SV  sv0;
-    SV  sv1 { s, 1 };
-    SV  sv2 { s, 2 };
-    SV  sv3 { s, 3 };
-    SV  sv4 { s, 4 };
-    SV  sv5 { s, 5 };
-    SV svNot {"def", 3 };
-
-    ASSERT_NOEXCEPT(s0.starts_with(sv0));
-
-    assert ( s0.starts_with(sv0));
-    assert (!s0.starts_with(sv1));
-
-    assert ( s1.starts_with(sv0));
-    assert ( s1.starts_with(sv1));
-    assert (!s1.starts_with(sv2));
-    assert (!s1.starts_with(sv3));
-    assert (!s1.starts_with(sv4));
-    assert (!s1.starts_with(sv5));
-    assert (!s1.starts_with(svNot));
-
-    assert ( s2.starts_with(sv0));
-    assert ( s2.starts_with(sv1));
-    assert ( s2.starts_with(sv2));
-    assert (!s2.starts_with(sv3));
-    assert (!s2.starts_with(sv4));
-    assert (!s2.starts_with(sv5));
-    assert (!s2.starts_with(svNot));
-
-    assert ( sNot.starts_with(sv0));
-    assert (!sNot.starts_with(sv1));
-    assert (!sNot.starts_with(sv2));
-    assert (!sNot.starts_with(sv3));
-    assert (!sNot.starts_with(sv4));
-    assert (!sNot.starts_with(sv5));
-    assert ( sNot.starts_with(svNot));
-
-    return true;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using S       = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV      = std::basic_string_view<CharT, std::char_traits<CharT> >;
+  const char* s = "abcde";
+
+  S s0;
+  S s1{s, 1};
+  S s2{s, 2};
+  //  S   s3  { s, 3 };
+  //  S   s4  { s, 4 };
+  //  S   s5  { s, 5 };
+  S sNot{"def", 3};
+
+  SV sv0;
+  SV sv1{s, 1};
+  SV sv2{s, 2};
+  SV sv3{s, 3};
+  SV sv4{s, 4};
+  SV sv5{s, 5};
+  SV svNot{"def", 3};
+
+  ASSERT_NOEXCEPT(s0.starts_with(sv0));
+
+  assert(s0.starts_with(sv0));
+  assert(!s0.starts_with(sv1));
+
+  assert(s1.starts_with(sv0));
+  assert(s1.starts_with(sv1));
+  assert(!s1.starts_with(sv2));
+  assert(!s1.starts_with(sv3));
+  assert(!s1.starts_with(sv4));
+  assert(!s1.starts_with(sv5));
+  assert(!s1.starts_with(svNot));
+
+  assert(s2.starts_with(sv0));
+  assert(s2.starts_with(sv1));
+  assert(s2.starts_with(sv2));
+  assert(!s2.starts_with(sv3));
+  assert(!s2.starts_with(sv4));
+  assert(!s2.starts_with(sv5));
+  assert(!s2.starts_with(svNot));
+
+  assert(sNot.starts_with(sv0));
+  assert(!sNot.starts_with(sv1));
+  assert(!sNot.starts_with(sv2));
+  assert(!sNot.starts_with(sv3));
+  assert(!sNot.starts_with(sv4));
+  assert(!sNot.starts_with(sv5));
+  assert(sNot.starts_with(svNot));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+
+  return true;
 }
 
 int main(int, char**)
diff --git a/libcxx/test/std/strings/strings.erasure/erase.pass.cpp b/libcxx/test/std/strings/strings.erasure/erase.pass.cpp
--- a/libcxx/test/std/strings/strings.erasure/erase.pass.cpp
+++ b/libcxx/test/std/strings/strings.erasure/erase.pass.cpp
@@ -72,5 +72,5 @@
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/std/strings/strings.erasure/erase_if.pass.cpp b/libcxx/test/std/strings/strings.erasure/erase_if.pass.cpp
--- a/libcxx/test/std/strings/strings.erasure/erase_if.pass.cpp
+++ b/libcxx/test/std/strings/strings.erasure/erase_if.pass.cpp
@@ -73,5 +73,5 @@
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/support/test_allocator.h b/libcxx/test/support/test_allocator.h
--- a/libcxx/test/support/test_allocator.h
+++ b/libcxx/test/support/test_allocator.h
@@ -28,38 +28,38 @@
 
 struct test_allocator_statistics {
   int time_to_throw = 0;
-  int throw_after = INT_MAX;
-  int count = 0;
-  int alloc_count = 0;
-  int copied = 0;
-  int moved = 0;
-  int converted = 0;
+  int throw_after   = INT_MAX;
+  int count         = 0;
+  int alloc_count   = 0;
+  int copied        = 0;
+  int moved         = 0;
+  int converted     = 0;
 
   TEST_CONSTEXPR_CXX14 void clear() {
     assert(count == 0 && "clearing leaking allocator data?");
-    count = 0;
+    count         = 0;
     time_to_throw = 0;
-    alloc_count = 0;
-    throw_after = INT_MAX;
+    alloc_count   = 0;
+    throw_after   = INT_MAX;
     clear_ctor_counters();
   }
 
   TEST_CONSTEXPR_CXX14 void clear_ctor_counters() {
-    copied = 0;
-    moved = 0;
+    copied    = 0;
+    moved     = 0;
     converted = 0;
   }
 };
 
 struct test_alloc_base {
   TEST_CONSTEXPR static const int destructed_value = -1;
-  TEST_CONSTEXPR static const int moved_value = INT_MAX;
+  TEST_CONSTEXPR static const int moved_value      = INT_MAX;
 };
 
 template <class T>
 class test_allocator {
-  int data_ = 0; // participates in equality
-  int id_ = 0;   // unique identifier, doesn't participate in equality
+  int data_                         = 0; // participates in equality
+  int id_                           = 0; // unique identifier, doesn't participate in equality
   test_allocator_statistics* stats_ = nullptr;
 
   template <class U>
@@ -89,7 +89,8 @@
   TEST_CONSTEXPR explicit test_allocator(int data) TEST_NOEXCEPT : data_(data) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), stats_(stats) {
+      : data_(data),
+        stats_(stats) {
     if (stats != nullptr)
       ++stats_->count;
   }
@@ -97,13 +98,17 @@
   TEST_CONSTEXPR explicit test_allocator(int data, int id) TEST_NOEXCEPT : data_(data), id_(id) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, int id, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), id_(id), stats_(stats) {
+      : data_(data),
+        id_(id),
+        stats_(stats) {
     if (stats_ != nullptr)
       ++stats_->count;
   }
 
   TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator& a) TEST_NOEXCEPT
-    : data_(a.data_), id_(a.id_), stats_(a.stats_) {
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {
     assert(a.data_ != test_alloc_base::destructed_value && a.id_ != test_alloc_base::destructed_value &&
            "copying from destroyed allocator");
     if (stats_ != nullptr) {
@@ -120,12 +125,14 @@
     assert(a.data_ != test_alloc_base::destructed_value && a.id_ != test_alloc_base::destructed_value &&
            "moving from destroyed allocator");
     a.data_ = test_alloc_base::moved_value;
-    a.id_ = test_alloc_base::moved_value;
+    a.id_   = test_alloc_base::moved_value;
   }
 
   template <class U>
   TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
-      : data_(a.data_), id_(a.id_), stats_(a.stats_) {
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {
     if (stats_ != nullptr) {
       ++stats_->count;
       ++stats_->converted;
@@ -138,7 +145,7 @@
     if (stats_ != nullptr)
       --stats_->count;
     data_ = test_alloc_base::destructed_value;
-    id_ = test_alloc_base::destructed_value;
+    id_   = test_alloc_base::destructed_value;
   }
 
   TEST_CONSTEXPR pointer address(reference x) const { return &x; }
@@ -183,7 +190,7 @@
 
 template <class T>
 class non_default_test_allocator {
-  int data_ = 0;
+  int data_                         = 0;
   test_allocator_statistics* stats_ = nullptr;
 
   template <class U>
@@ -205,7 +212,8 @@
 
   TEST_CONSTEXPR_CXX14
   explicit non_default_test_allocator(int i, test_allocator_statistics* stats = nullptr) TEST_NOEXCEPT
-      : data_(i), stats_(stats) {
+      : data_(i),
+        stats_(stats) {
     if (stats_ != nullptr) {
       ++stats_->count;
     }
@@ -219,7 +227,8 @@
 
   template <class U>
   TEST_CONSTEXPR_CXX14 non_default_test_allocator(const non_default_test_allocator<U>& a) TEST_NOEXCEPT
-      : data_(a.data_), stats_(a.stats_) {
+      : data_(a.data_),
+        stats_(a.stats_) {
     if (stats_ != nullptr)
       ++stats_->count;
   }
@@ -265,8 +274,8 @@
 
 template <>
 class test_allocator<void> {
-  int data_ = 0;
-  int id_ = 0;
+  int data_                         = 0;
+  int id_                           = 0;
   test_allocator_statistics* stats_ = nullptr;
 
   template <class U>
@@ -291,27 +300,30 @@
   TEST_CONSTEXPR explicit test_allocator(int data) TEST_NOEXCEPT : data_(data) {}
 
   TEST_CONSTEXPR explicit test_allocator(int data, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), stats_(stats)
-  {}
+      : data_(data),
+        stats_(stats) {}
 
   TEST_CONSTEXPR explicit test_allocator(int data, int id) : data_(data), id_(id) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, int id, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), id_(id), stats_(stats)
-  {}
+      : data_(data),
+        id_(id),
+        stats_(stats) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(const test_allocator& a) TEST_NOEXCEPT
-      : data_(a.data_), id_(a.id_), stats_(a.stats_)
-  {}
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {}
 
   template <class U>
   TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
-      : data_(a.data_), id_(a.id_), stats_(a.stats_)
-  {}
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {}
 
   TEST_CONSTEXPR_CXX20 ~test_allocator() TEST_NOEXCEPT {
     data_ = test_alloc_base::destructed_value;
-    id_ = test_alloc_base::destructed_value;
+    id_   = test_alloc_base::destructed_value;
   }
 
   TEST_CONSTEXPR int get_id() const { return id_; }
@@ -377,9 +389,9 @@
   TEST_CONSTEXPR Tag_X(Ctor_Tag, Args&&...) {}
 
   // not DefaultConstructible, CopyConstructible or MoveConstructible.
-  Tag_X() = delete;
+  Tag_X()             = delete;
   Tag_X(const Tag_X&) = delete;
-  Tag_X(Tag_X&&) = delete;
+  Tag_X(Tag_X&&)      = delete;
 
   // CopyAssignable.
   TEST_CONSTEXPR_CXX14 Tag_X& operator=(const Tag_X&) { return *this; };
@@ -396,7 +408,7 @@
 template <typename T>
 class TaggingAllocator {
 public:
-  using value_type = T;
+  using value_type   = T;
   TaggingAllocator() = default;
 
   template <typename U>
@@ -423,13 +435,13 @@
 template <std::size_t MaxAllocs>
 struct limited_alloc_handle {
   std::size_t outstanding_ = 0;
-  void* last_alloc_ = nullptr;
+  void* last_alloc_        = nullptr;
 
   template <class T>
   TEST_CONSTEXPR_CXX20 T* allocate(std::size_t N) {
     if (N + outstanding_ > MaxAllocs)
       TEST_THROW(std::bad_alloc());
-    auto alloc = std::allocator<T>().allocate(N);
+    auto alloc  = std::allocator<T>().allocate(N);
     last_alloc_ = alloc;
     outstanding_ += N;
     return alloc;