[libc++] Refactor string unit tests to ease addition of new allocators

[ldionne]

Summary

While doing this, I also found a few tests that were either clearly
incorrect (e.g. testing the wrong function) or that lacked basic test
coverage like testing std::string itself (e.g. the test was only checking
std::basic_string with a custom allocator). In these cases, I did a few
conservative drive-by changes.

[bemeryesr]

Move wide char alias into ifdef

[bemeryesr]

Apply clang formatting to changed files

[ldionne]

Thanks for the patch. It took some time to look at it, so it must have been pretty tedious to write it, but I think it's a good improvement overall.

Given the huge number of changes, I might have made the changes without touching the formatting at all to reduce the diff as much as possible, and then do the formatting changes (or not at all). But anyway, they're here now and I've reviewed it like that, so let's not change it. Just something to consider for the future.

Let's try to get this landed quickly to avoid getting stuck in endless rebase conflict resolutions.

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

61–62

Instead, I would do:

template <class String>
constexpr bool test() {
  test_appending<String>(...);
  ...
}

WDYT?

87–96

The whitespace between test_string calls and static_asserts seems superfluous.

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

112

We generally don't specialize function templates. This is a red flag to me. Why do we need this specialization?

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

39

Same comment about specializing.

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

59

There's a functional difference here -- we used to use a different allocator object for each call to test(....), and now they all share the same a. Instead, you could perhaps use test(s, s, Alloc(a)) (etc...).

This situation arises in several tests, so whatever we do to fix it, you should apply it consistently throughout this patch.

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

38–41 ↗

(On Diff #485057)

Please conserve the previous formatting, it highlighted the expression being checked much better.

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

42–48 ↗

(On Diff #485057)

Same: conserve formatting.

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

57–60

Please keep each of these calls a single line, even if that makes it a long line. It makes the structure clearer.

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

79 ↗

(On Diff #485057)

Same comment about line breaks.

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

1071 ↗

(On Diff #485057)

I don't think this change is intended.

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

1011 ↗

(On Diff #485057)

Same. Multiple files have this issue, please check them all.

libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp

36

Function template specialization = red flag.

libcxx/test/support/test_allocator.h

23 ↗

(On Diff #485057)

The changes to this file are purely formatting, so I'd drop them.

[bemeryesr]

In D140550#4037134, @ldionne wrote:

Thanks for the patch. It took some time to look at it, so it must have been pretty tedious to write it, but I think it's a good improvement overall.

Given the huge number of changes, I might have made the changes without touching the formatting at all to reduce the diff as much as possible, and then do the formatting changes (or not at all). But anyway, they're here now and I've reviewed it like that, so let's not change it. Just something to consider for the future.

Let's try to get this landed quickly to avoid getting stuck in endless rebase conflict resolutions.

Thanks for the quick review! I will work on this today.

I completely agree with you about the formatting changes. I actually initially tried to have this PR just include the actual changes (and not the formatting changes) but when I submitted the PR using arc, it forced me to apply the clang formatting (or at least it seemed that way to me, perhaps I did something wrong). Is there a way to submit the patch without applying the clang formatting to all touched files?

As a side note, based on your comments about the formatting, perhaps you want to weigh in on this PR of mine: https://reviews.llvm.org/D140612.

[philnik]

In D140550#4039032, @bemeryesr wrote:

In D140550#4037134, @ldionne wrote:

Thanks for the patch. It took some time to look at it, so it must have been pretty tedious to write it, but I think it's a good improvement overall.

Given the huge number of changes, I might have made the changes without touching the formatting at all to reduce the diff as much as possible, and then do the formatting changes (or not at all). But anyway, they're here now and I've reviewed it like that, so let's not change it. Just something to consider for the future.

Let's try to get this landed quickly to avoid getting stuck in endless rebase conflict resolutions.

Thanks for the quick review! I will work on this today.

I completely agree with you about the formatting changes. I actually initially tried to have this PR just include the actual changes (and not the formatting changes) but when I submitted the PR using arc, it forced me to apply the clang formatting (or at least it seemed that way to me, perhaps I did something wrong). Is there a way to submit the patch without applying the clang formatting to all touched files?

As a side note, based on your comments about the formatting, perhaps you want to weigh in on this PR of mine: https://reviews.llvm.org/D140612.

You can us the --nolint flag when updating the PR to ignore clang-format.

[bemeryesr]

• Remove formatting-only changes.
• Remove function template specializations.
• Address remaining feedback from Idionne.

[bemeryesr]

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

112

I just added it since the test_allocator needs to be treated differently within the test (i.e. initialised with a value) and wanted to keep the calling code consistent. But I'll remove the function template specialization.

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

79 ↗

(On Diff #485057)

This change was just formatting so I've removed it.

[bemeryesr]

Remove whitespaces at the end of lines.

[bemeryesr]

Rebasing on main

[ldionne]

Commandeering to rebase.

[ldionne]

Rebase.

[ldionne]

I was fine with this patch back then, I still think it's good.

I'll ship it if the CI is green.

[ldionne]

Rebase onto clang-format.

[ldionne]

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

72

TODO: check this refactoring.

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

80

TODO: check this one.

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

89

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

25

TODO: check this one and everything below.

[ldionne]

Go over all the tests and fix some refactorings that weren't the way they should.

[ldionne]

Update ignore_format.txt

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

 // UNSUPPORTED: libcpp-hardening-mode=unchecked
 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
 
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.pass.cpp

 // UNSUPPORTED: libcpp-hardening-mode=unchecked
 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
 
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.pass.cpp

 // UNSUPPORTED: libcpp-hardening-mode=unchecked
 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
-  {
-    typedef std::string S;
-    const S s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
-  }
+template <class S>
+void test() {
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.pass.cpp

 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
 
-  {
-    typedef std::string S;
-    const S s;
-    assert(s[0] == 0);
-    TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

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

 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
-  {
-    typedef std::string S;
-    S s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
-  }
+template <class S>
+void test() {
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

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

 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.add.pass.cpp

 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class C>
+void test() {
+  typename C::iterator i = c.begin();
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.pass.cpp

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.pass.cpp

 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class C>
+void test() {
+  typename C::iterator i = c.end();
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.pass.cpp

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class C>
+void test() {
+  typename C::iterator i = c.end();
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.pass.cpp

 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class C>
+void test() {
+  typename C::iterator i = c.begin();
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp

 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+template <class C>
+void test() {
   using T = decltype(std::uint8_t() - std::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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.pass.cpp

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.erase_iter.null.pass.cpp

 // UNSUPPORTED: libcpp-hardening-mode=unchecked
 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
+  typename S::const_iterator i = l1.end();
 
-  {
-    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");
-  }
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.pass.cpp

 // UNSUPPORTED: c++03
 // UNSUPPORTED: libcpp-hardening-mode=unchecked
 // XFAIL: availability-verbose_abort-missing
 
 #include <string>
 
 #include "check_assertion.h"
 
-int main(int, char**) {
-  std::string s;
+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**) {
+  test<std::string>();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter.pass.cpp

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+void test() {
+  typename S::const_iterator i = l2.begin();
 
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter_iter.pass.cpp

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+template <class S>
+void test() {
   // 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");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), l1.cbegin() + 1),
   }
-}
 
   // 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");
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), l2.cbegin() + 1),
   }
-}
 
   // 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;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.pass.cpp

 //       Until we overhaul the debug mode, mark this test as unsupported to avoid
 //       spurious CI failures.
 // REQUIRES: never-run
 
 #include <string>
 
 #include "check_assertion.h"
 
-int main(int, char**) {
-  typedef std::string S;
+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**) {
+  test<std::string>();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.pass.cpp

 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 
-int main(int, char**) {
-  std::string v;
-  std::string v2;
+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**) {
+  test<std::string>();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_size_char.pass.cpp

 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-legacy-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 
-int main(int, char**) {
-  std::string s;
-  std::string s2;
+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**) {
+  test<std::string>();
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp

 
 TEST_CONSTEXPR_CXX20 void write_c_str(char* buf, int size) {
   for (int i = 0; i < size; ++i) {
     buf[i] = 'a';
   }
   buf[size] = '\0';
 }
 
+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);
     assert(std::char_traits<char>().length(s.data()) == used_size);
     s.__resize_default_init(used_size);
     assert(s.size() == used_size);
     assert(s.data()[used_size] == '\0');
     for (unsigned i = 0; i < used_size; ++i) {
       assert(s[i] == 'a');
     }
   }
 }
 
+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');
     for (int i = 0; i < 3; ++i)
       s[i] = 'a' + i;
     s.__resize_default_init(1);
     assert(s[0] == 'a');
     assert(s.data()[1] == '\0');
     assert(s.size() == 1);
   }
 }
 
+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;
 }

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

 #include <cassert>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test(S s, test_allocator_statistics& alloc_stats) {
+TEST_CONSTEXPR_CXX20 void test_invariant(S s, test_allocator_statistics& alloc_stats) {
   alloc_stats.throw_after = 0;
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try
 #endif
   {
     while (s.size() < s.capacity())
       s.push_back(typename S::value_type());
     assert(s.size() == s.capacity());
   }
 #ifndef TEST_HAS_NO_EXCEPTIONS
   catch (...) {
     assert(false);
   }
 #endif
   alloc_stats.throw_after = INT_MAX;
 }
 
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  using S = std::basic_string<char, std::char_traits<char>, Alloc>;
+  {
+    S const s((Alloc(a)));
+    assert(s.capacity() >= 0);
+  }
+  {
+    S const s(3, 'x', Alloc(a));
+    assert(s.capacity() >= 3);
+  }
+#if TEST_STD_VER >= 11
+  // Check that we perform SSO
+  {
+    S const s;
+    assert(s.capacity() > 0);
+    ASSERT_NOEXCEPT(s.capacity());
+  }
+#endif
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(3));
+  test_string(min_allocator<char>());
+
   {
     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);
+    test_invariant(s, alloc_stats);
     s.assign(10, 'a');
     s.erase(5);
-    test(s, alloc_stats);
+    test_invariant(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_invariant(s, alloc_stats);
   }
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
-#if TEST_STD_VER > 17
+#if TEST_STD_VER >= 20
   static_assert(test());
 #endif
 
   return 0;
 }

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

 #include <string>
 #include <cassert>
 #include <new>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test1(const S& s) {
+TEST_CONSTEXPR_CXX20 void test_resize_max_size_minus_1(const S& s) {
   S s2(s);
   const std::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) {
+TEST_CONSTEXPR_CXX20 void test_resize_max_size(const S& s) {
   S s2(s);
   const std::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) {
+TEST_CONSTEXPR_CXX20 void test_string() {
+  {
+    S s;
     assert(s.max_size() >= s.size());
-  test1(s);
-  test2(s);
+    assert(s.max_size() > 0);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+      test_resize_max_size_minus_1(s);
+      test_resize_max_size(s);
+    }
+  }
+  {
+    S s("123");
+    assert(s.max_size() >= s.size());
+    assert(s.max_size() > 0);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+      test_resize_max_size_minus_1(s);
+      test_resize_max_size(s);
+    }
+  }
+  {
+    S s("12345678901234567890123456789012345678901234567890");
+    assert(s.max_size() >= s.size());
+    assert(s.max_size() > 0);
+    if (!TEST_IS_CONSTANT_EVALUATED) {
+      test_resize_max_size_minus_1(s);
+      test_resize_max_size(s);
+    }
   }
-
-template <class S>
-TEST_CONSTEXPR_CXX20 void test_string() {
-  test(S());
-  test(S("123"));
-  test(S("12345678901234567890123456789012345678901234567890"));
 }
 
 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;
-
-  std::size_t size = str.max_size();
-  assert(size > 0);
-
-  return true;
-}
-#endif
-
 int main(int, char**) {
   test();
-#if TEST_STD_VER > 17
-  test_constexpr();
-  static_assert(test_constexpr());
+#if TEST_STD_VER >= 20
+  static_assert(test());
 #endif
 
   return 0;
 }

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

s.resize_and_overwrite(N, [&](auto* p, auto n) {
     p[n]     = 'c'; // will be overwritten
     return n;
   });
   const S expected = S(N - 1, 'a') + S(1, 'b');
   assert(s == expected);
   assert(s.c_str()[N] == '\0');
 }
 
-template <class CharT>
+template <class String>
 constexpr bool test() {
-  using S = std::basic_string<CharT>;
-  test_appending<S>(10, 15, 15);
-  test_appending<S>(10, 15, 20);
-  test_appending<S>(10, 40, 40);
-  test_appending<S>(10, 40, 50);
-  test_appending<S>(30, 35, 35);
-  test_appending<S>(30, 35, 45);
-  test_appending<S>(10, 15, 30);
-  test_truncating<S>(15, 10);
-  test_truncating<S>(40, 35);
-  test_truncating<S>(40, 10);
+  test_appending<String>(10, 15, 15);
+  test_appending<String>(10, 15, 20);
+  test_appending<String>(10, 40, 40);
+  test_appending<String>(10, 40, 50);
+  test_appending<String>(30, 35, 35);
+  test_appending<String>(30, 35, 45);
+  test_appending<String>(10, 15, 30);
+  test_truncating<String>(15, 10);
+  test_truncating<String>(40, 35);
+  test_truncating<String>(40, 10);
 
   return true;
 }
 
 void test_value_categories() {
   std::string s;
   s.resize_and_overwrite(10, [](char*&&, std::size_t&&) { return 0; });
   s.resize_and_overwrite(10, [](char* const&, const std::size_t&) { return 0; });
   struct RefQualified {
     int operator()(char*, std::size_t) && { return 0; }
   };
   s.resize_and_overwrite(10, RefQualified{});
 }
 
 int main(int, char**) {
-  test<char>();
-  test<char8_t>();
-  test<char16_t>();
-  test<char32_t>();
-
-  static_assert(test<char>());
-  static_assert(test<char8_t>());
-  static_assert(test<char16_t>());
-  static_assert(test<char32_t>());
+  test<std::basic_string<char, std::char_traits<char>, std::allocator<char>>>();
+  test<std::basic_string<char8_t, std::char_traits<char8_t>, std::allocator<char8_t>>>();
+  test<std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>();
+  test<std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>>();
+
+  static_assert(test<std::basic_string<char, std::char_traits<char>, std::allocator<char>>>());
+  static_assert(test<std::basic_string<char8_t, std::char_traits<char8_t>, std::allocator<char8_t>>>());
+  static_assert(test<std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>());
+  static_assert(test<std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>>());
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-  static_assert(test<wchar_t>());
+  test<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>();
+  static_assert(test<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>());
 #endif
   return 0;
 }

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

if (pos <= sv.size()) {
     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());
     }
   }
 #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;
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  typedef std::basic_string<char, std::char_traits<char>, Alloc> 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));
-  }
+  test<S, SV>(SV(), 0, 0, Alloc(a));
+  test<S, SV>(SV(), 0, 1, Alloc(a));
+  test<S, SV>(SV(), 1, 0, Alloc(a));
+  test<S, SV>(SV(), 1, 1, Alloc(a));
+  test<S, SV>(SV(), 1, 2, Alloc(a));
+  test<S, SV>(SV("1"), 0, 0, Alloc(a));
+  test<S, SV>(SV("1"), 0, 1, Alloc(a));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0, Alloc(a));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1, Alloc(a));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10, Alloc(a));
+  test<S, SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100, Alloc(a));
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(8));
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string_view<char, std::char_traits<char> > SV;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-
-    test<S, SV>(SV(), 0, 0);
-    test<S, SV>(SV(), 0, 1);
-    test<S, SV>(SV(), 1, 0);
-    test<S, SV>(SV(), 1, 1);
-    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(min_allocator<char>());
 #endif
+
   {
     typedef std::string S;
     typedef std::string_view SV;
     S s        = "ABCD";
     SV sv      = "EFGH";
     char arr[] = "IJKL";
 
     S s1("CDEF", 4); // calls ctor(const char *, len)

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

 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 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)));
-  }
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  typedef std::basic_string<char, std::char_traits<char>, Alloc> S;
+  test(S(Alloc(a)));
+  test(S("1", Alloc(a)));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a)));
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(3));
 #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(min_allocator<char>());
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test_assign(S& s1, const S& 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);
 }
 
-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));
-  }
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  typedef std::basic_string<char, std::char_traits<char>, Alloc> S;
+  test(S(), Alloc(a));
+  test(S("1"), Alloc(a));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), Alloc(a));
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(3));
 #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(min_allocator<char>());
+#endif
 
+#if TEST_STD_VER >= 11
 #  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";
 
     alloc_imp imp1;

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

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

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

 // basic_string& operator=(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
+// clang-format off
+template <template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
   {
-    std::string s;
-    s = {'a', 'b', 'c'};
+    typedef std::basic_string<char, std::char_traits<char>, Alloc<char>> S;
+    S s;
+    S& result = (s = {'a', 'b', 'c'});
     assert(s == "abc");
+    assert(&result == &s);
   }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t>> S;
     S s;
-    s = {'a', 'b', 'c'};
-    assert(s == "abc");
+    S& result = (s = {L'a', L'b', L'c'});
+    assert(s == L"abc");
+    assert(&result == &s);
   }
+#endif
+}
+// clang-format on
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::allocator>();
+  test_string<min_allocator>();
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-template <class It>
+template <class Alloc, 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;
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> S;
   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.get_allocator() == Alloc());
   assert(s2.capacity() >= s2.size());
 }
 
-template <class It, class A>
-TEST_CONSTEXPR_CXX20 void test(It first, It last, const A& a) {
+template <class Alloc, class It>
+TEST_CONSTEXPR_CXX20 void test(It first, It last, const Alloc& a) {
   typedef typename std::iterator_traits<It>::value_type charT;
-  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> 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";
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
 
-    test(s, s);
-    test(s, s, A(2));
+  test<Alloc>(s, s);
+  test<Alloc>(s, s, Alloc(a));
 
-    test(s, s + 1);
-    test(s, s + 1, A(2));
+  test<Alloc>(s, s + 1);
+  test<Alloc>(s, s + 1, Alloc(a));
 
-    test(s, s + 10);
-    test(s, s + 10, A(2));
+  test<Alloc>(s, s + 10);
+  test<Alloc>(s, s + 10, Alloc(a));
 
-    test(s, s + 50);
-    test(s, s + 50, A(2));
+  test<Alloc>(s, s + 50);
+  test<Alloc>(s, s + 50, Alloc(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<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
+  test<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), Alloc(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<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1));
+  test<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1), Alloc(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<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 10));
+  test<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 10), Alloc(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(s, s);
-    test(s, s, A());
-
-    test(s, s + 1);
-    test(s, s + 1, A());
-
-    test(s, s + 10);
-    test(s, s + 10, A());
+  test<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 50));
+  test<Alloc>(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 50), Alloc(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_CONSTEXPR_CXX20 bool test() {
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test_string(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), "");
   }
 
   return true;
 }

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

 
 #include "test_macros.h"
 #include "test_allocator.h"
 #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 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()));
-  }
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(Alloc const& a) {
+  using S = std::basic_string<char, std::char_traits<char>, Alloc>;
+  test(S(Alloc(a)));
+  test(S("1", Alloc(a)));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a)));
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(3));
+  test_string(min_allocator<char>());
+
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-template <class charT>
+template <class Alloc, class charT>
 TEST_CONSTEXPR_CXX20 void test(const charT* s) {
-  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> 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.get_allocator() == Alloc());
   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;
+template <class Alloc, class charT>
+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;
-
-    test("");
-    test("", A(2));
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const Alloc& a) {
+  test<Alloc>("");
+  test<Alloc>("", Alloc(a));
 
-    test("1");
-    test("1", A(2));
+  test<Alloc>("1");
+  test<Alloc>("1", Alloc(a));
 
-    test("1234567980");
-    test("1234567980", A(2));
+  test<Alloc>("1234567980");
+  test<Alloc>("1234567980", Alloc(a));
 
-    test("123456798012345679801234567980123456798012345679801234567980");
-    test("123456798012345679801234567980123456798012345679801234567980", A(2));
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-
-    test("");
-    test("", A());
-
-    test("1");
-    test("1", A());
+  test<Alloc>("123456798012345679801234567980123456798012345679801234567980");
+  test<Alloc>("123456798012345679801234567980123456798012345679801234567980", Alloc(a));
 
-    test("1234567980");
-    test("1234567980", A());
-
-    test("123456798012345679801234567980123456798012345679801234567980");
-    test("123456798012345679801234567980123456798012345679801234567980", A());
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test(std::allocator<char>());
+  test(test_allocator<char>());
+  test(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test(min_allocator<char>());
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #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;
+template <class Alloc, class CharT>
+TEST_CONSTEXPR_CXX20 void test(const CharT* s, unsigned n) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc> 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.get_allocator() == Alloc());
   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;
+template <class Alloc, class CharT>
+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;
-
-    test("", 0);
-    test("", 0, A(2));
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const Alloc& a) {
+  test<Alloc>("", 0);
+  test<Alloc>("", 0, Alloc(a));
 
-    test("1", 1);
-    test("1", 1, A(2));
+  test<Alloc>("1", 1);
+  test<Alloc>("1", 1, Alloc(a));
 
-    test("1234567980", 10);
-    test("1234567980", 10, A(2));
+  test<Alloc>("1234567980", 10);
+  test<Alloc>("1234567980", 10, Alloc(a));
 
-    test("123456798012345679801234567980123456798012345679801234567980", 60);
-    test("123456798012345679801234567980123456798012345679801234567980", 60, A(2));
-  }
-#if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-
-    test("", 0);
-    test("", 0, A());
-
-    test("1", 1);
-    test("1", 1, A());
+  test<Alloc>("123456798012345679801234567980123456798012345679801234567980", 60);
+  test<Alloc>("123456798012345679801234567980123456798012345679801234567980", 60, Alloc(a));
 
-    test("1234567980", 10);
-    test("1234567980", 10, A());
-
-    test("123456798012345679801234567980123456798012345679801234567980", 60);
-    test("123456798012345679801234567980123456798012345679801234567980", 60, A());
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test(std::allocator<char>());
+  test(test_allocator<char>());
+  test(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test(min_allocator<char>());
 #endif
 
 #if TEST_STD_VER >= 11
   { // LWG 2946
     std::string s({"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");
   }

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

 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-template <class charT>
+template <class Alloc, 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;
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> S;
   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.get_allocator() == Alloc());
   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;
+template <class Alloc, class charT>
+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>
+template <class Alloc, 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;
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> S;
   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.get_allocator() == Alloc());
   assert(s2.capacity() >= s2.size());
 }
 
-template <class Tp, class A>
-TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c, const A& a) {
+template <class Alloc, class Tp>
+TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c, const Alloc& a) {
   typedef char charT;
-  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> 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;
-
-    test(0, 'a');
-    test(0, 'a', A(2));
-
-    test(1, 'a');
-    test(1, 'a', A(2));
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  test<Alloc>(0, 'a');
+  test<Alloc>(0, 'a', Alloc(a));
+
+  test<Alloc>(1, 'a');
+  test<Alloc>(1, 'a', Alloc(a));
 
-    test(10, 'a');
-    test(10, 'a', A(2));
+  test<Alloc>(10, 'a');
+  test<Alloc>(10, 'a', Alloc(a));
 
-    test(100, 'a');
-    test(100, 'a', A(2));
+  test<Alloc>(100, 'a');
+  test<Alloc>(100, 'a', Alloc(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;
-
-    test(0, 'a');
-    test(0, 'a', A());
-
-    test(1, 'a');
-    test(1, 'a', A());
+  test<Alloc>(static_cast<char>(100), static_cast<char>(65));
+  test<Alloc>(static_cast<char>(100), static_cast<char>(65), a);
 
-    test(10, 'a');
-    test(10, 'a', A());
-
-    test(100, 'a');
-    test(100, 'a', A());
-
-    test(static_cast<char>(100), static_cast<char>(65));
-    test(static_cast<char>(100), static_cast<char>(65), A());
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test_string(min_allocator<char>());
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "test_macros.h"
 
 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;
+template <class Alloc, class CharT>
+TEST_CONSTEXPR_CXX20 void test(std::basic_string_view<CharT> sv) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc> S;
   typedef typename S::traits_type T;
-  typedef typename S::allocator_type A;
   {
     S s2(sv);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
-    assert(s2.get_allocator() == A());
+    assert(s2.get_allocator() == Alloc());
     assert(s2.capacity() >= s2.size());
   }
   {
     S s2;
     s2 = sv;
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
-    assert(s2.get_allocator() == A());
+    assert(s2.get_allocator() == Alloc());
     assert(s2.capacity() >= s2.size());
   }
 }
 
-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;
+template <class Alloc, class CharT>
+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());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
   }
   {
     S s2(a);
     s2 = sv;
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
   }
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string_view<char, std::char_traits<char> > SV;
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
 
-    test(SV(""));
-    test(SV(""), A(2));
+  test<Alloc>(SV(""));
+  test<Alloc>(SV(""), Alloc(a));
 
-    test(SV("1"));
-    test(SV("1"), A(2));
+  test<Alloc>(SV("1"));
+  test<Alloc>(SV("1"), Alloc(a));
 
-    test(SV("1234567980"));
-    test(SV("1234567980"), A(2));
+  test<Alloc>(SV("1234567980"));
+  test<Alloc>(SV("1234567980"), Alloc(a));
 
-    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<Alloc>(SV("123456798012345679801234567980123456798012345679801234567980"));
+  test<Alloc>(SV("123456798012345679801234567980123456798012345679801234567980"), Alloc(a));
 
-    test(SV("1"));
-    test(SV("1"), A());
-
-    test(SV("1234567980"));
-    test(SV("1234567980"), A());
-
-    test(SV("123456798012345679801234567980123456798012345679801234567980"));
-    test(SV("123456798012345679801234567980123456798012345679801234567980"), A());
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test_string(min_allocator<char>());
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

try {
       assert(pos > str.size());
     }
   }
 #endif
 }
 
 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;
+  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
 }
 
-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));
-  }
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a1, const Alloc& a2) {
+  using S = std::basic_string<char, std::char_traits<char>, Alloc>;
+
+  test(S(Alloc(a1)), 0);
+  test(S(Alloc(a1)), 1);
+  test(S("1", Alloc(a1)), 0);
+  test(S("1", Alloc(a1)), 1);
+  test(S("1", Alloc(a1)), 2);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 5);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 500);
+
+  test(S(Alloc(a1)), 0, 0);
+  test(S(Alloc(a1)), 0, 1);
+  test(S(Alloc(a1)), 1, 0);
+  test(S(Alloc(a1)), 1, 1);
+  test(S(Alloc(a1)), 1, 2);
+  test(S("1", Alloc(a1)), 0, 0);
+  test(S("1", Alloc(a1)), 0, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 10);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 100);
+
+  test(S(Alloc(a1)), 0, 0, Alloc(a2));
+  test(S(Alloc(a1)), 0, 1, Alloc(a2));
+  test(S(Alloc(a1)), 1, 0, Alloc(a2));
+  test(S(Alloc(a1)), 1, 1, Alloc(a2));
+  test(S(Alloc(a1)), 1, 2, Alloc(a2));
+  test(S("1", Alloc(a1)), 0, 0, Alloc(a2));
+  test(S("1", Alloc(a1)), 0, 1, Alloc(a2));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 0, Alloc(a2));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 1, Alloc(a2));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 10, Alloc(a2));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a1)), 50, 100, Alloc(a2));
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>(), std::allocator<char>());
+  test_string(test_allocator<char>(), test_allocator<char>());
+  test_string(test_allocator<char>(3), test_allocator<char>(5));
 #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(min_allocator<char>(), min_allocator<char>());
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
   test_lwg2583();
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

 
 // constexpr bool contains(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  using S = std::string;
-
+template <class S>
+constexpr 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'));
+}
+
+constexpr bool test() {
+  test_string<std::string>();
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

 
 // constexpr bool contains(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  using S = std::string;
-
+template <class S>
+constexpr void test_string() {
   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"));
constexpr void test_string() {
   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"));
+}
+
+constexpr bool test() {
+  test_string<std::string>();
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 
 // constexpr bool contains(basic_string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  using S  = std::string;
-  using SV = std::string_view;
+template <class CharT, template <class> class Alloc>
+constexpr 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};
 
constexpr void test_string() {
   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));
+}
+
+constexpr bool test() {
+  test_string<char, std::allocator>();
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp

 
 // constexpr bool ends_with(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    S s1{};
-    S s2{"abcde", 5};
+template <class S>
+constexpr void test_string() {
 
-    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'));
-  }
 
+constexpr bool test() {
+  test_string<std::string>();
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp

 
 // constexpr bool ends_with(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    const char* s = "abcde";
+template <class S>
+constexpr void test_string() {
 
-    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(""));
 
-    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(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"));
-  }
 
+constexpr bool test() {
+  test_string<std::string>();
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 
 // constexpr bool ends_with(basic_string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    const char* s = "abcde";
+template <class CharT, template <class> class Alloc>
+constexpr 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> >;
 
-    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));
-  }
 
+constexpr bool test() {
+  test_string<char, std::allocator>();
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp

TEST_CONSTEXPR_CXX20 void test(S 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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp

 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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp

 #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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp

 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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp

 #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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp

TEST_CONSTEXPR_CXX20 void test(S s) {
   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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp

TEST_CONSTEXPR_CXX20 void test(S 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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp

TEST_CONSTEXPR_CXX20 void test(S s) {
   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 bool test() {
-  {
-    typedef std::string S;
-    test(S());
-    test(S("123"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S());
-    test(S("123"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 
 template <class T>
 struct Charlike {
   char ch_;
   TEST_CONSTEXPR Charlike(char ch) : ch_(ch) {}
   TEST_CONSTEXPR operator char() const { return ch_; }
 };
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  std::string s;
+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() {
+  test_string<std::string>();
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test_exceptions(S s, It first, It last) {
   assert(s == original);
   assert(s.begin() == begin);
   assert(s.end() == end);
 }
 #endif
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
+  {
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s + 1, S("A"));
     test(S(), s, s + 10, S("ABCDEFGHIJ"));
     test(S(), s, s + 52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), s, s, S("12345"));
     test(S("12345"), s, s + 1, S("12345A"));
     test(S("12345"), s, s + 10, S("12345ABCDEFGHIJ"));
     test(S("12345"), s, s + 52, S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("1234567890"), s, s, S("1234567890"));
     test(S("1234567890"), s, s + 1, S("1234567890A"));
     test(S("1234567890"), s, s + 10, S("1234567890ABCDEFGHIJ"));
     test(S("1234567890"), s, s + 52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"), s, s, S("12345678901234567890"));
     test(S("12345678901234567890"),
          s,
          s + 1,
          S("12345678901234567890"
            "A"));
     test(S("12345678901234567890"),
          s,
          s + 10,
          S("12345678901234567890"
            "ABCDEFGHIJ"));
     test(S("12345678901234567890"),
          s,
          s + 52,
          S("12345678901234567890"
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
     test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1), S("A"));
     test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 10), S("ABCDEFGHIJ"));
     test(S(),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345"));
     test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1), S("12345A"));
     test(S("12345"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 10),
          S("12345ABCDEFGHIJ"));
     test(S("12345"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("1234567890"));
     test(S("1234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 1),
          S("1234567890A"));
     test(S("1234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 10),
          S("1234567890ABCDEFGHIJ"));
     test(S("1234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s),
          S("12345678901234567890"));
     test(S("12345678901234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 1),
          S("12345678901234567890"
            "A"));
     test(S("12345678901234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 10),
          S("12345678901234567890"
            "ABCDEFGHIJ"));
     test(S("12345678901234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("12345678901234567890"
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
   }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  test_string<std::string>();
-#if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
-#endif
-
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
-    typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s + 10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s + 10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s + 10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), TIter(s, s + 10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s + 10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s + 10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), w, w + 100);
   }
 #endif
 
   { // test appending to self
-    typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.append(s_short.begin(), s_short.end());
     assert(s_short == "123/123/");
     s_short.append(s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/");
     s_short.append(s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.append(s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   { // test appending a different type
-    typedef std::string S;
     const std::uint8_t p[] = "ABCD";
 
     S s;
     s.append(p, p + 4);
     assert(s == "ABCD");
   }
 
   { // regression-test appending to self in sneaky ways
-    std::string s_short     = "hello";
-    std::string s_long      = "Lorem ipsum dolor sit amet, consectetur/";
-    std::string s_othertype = "hello";
-    std::string s_sneaky    = "hello";
+    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_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,
-         std::string("Lorem ipsum dolor sit amet, consectetur/\0", 41));
+         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"));
+      test(s_othertype, first + 2, first + 5, S("hellollo"));
     }
   }
 
   { // test with a move iterator that returns char&&
     typedef forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
-    std::string s;
+    S s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
   { // test with a move iterator that returns char&&
     typedef const char* It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
-    std::string s;
+    S s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+#endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

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

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

 // basic_string& assign(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+#endif
+
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

void test_exceptions(S s, It first, It last) {
   assert(s == original);
   assert(s.begin() == begin);
   assert(s.end() == end);
 }
 #endif
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
+  {
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s + 1, S("A"));
     test(S(), s, s + 10, S("ABCDEFGHIJ"));
     test(S(), s, s + 52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), s, s, S());
     test(S("12345"), s, s + 1, S("A"));
     test(S("12345"), s, s + 10, S("ABCDEFGHIJ"));
     test(S("12345"), s, s + 52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("1234567890"), s, s, S());
     test(S("1234567890"), s, s + 1, S("A"));
     test(S("1234567890"), s, s + 10, S("ABCDEFGHIJ"));
     test(S("1234567890"), s, s + 52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"), s, s, S());
     test(S("12345678901234567890"), s, s + 1, S("A"));
     test(S("12345678901234567890"), s, s + 10, S("ABCDEFGHIJ"));
     test(S("12345678901234567890"), s, s + 52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
     test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1), S("A"));
     test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 10), S("ABCDEFGHIJ"));
     test(S(),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
     test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1), S("A"));
     test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 10), S("ABCDEFGHIJ"));
     test(S("12345"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
     test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 1), S("A"));
     test(S("1234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 10),
          S("ABCDEFGHIJ"));
     test(S("1234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
     test(S("12345678901234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 1),
          S("A"));
     test(S("12345678901234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 10),
          S("ABCDEFGHIJ"));
     test(S("12345678901234567890"),
          cpp17_input_iterator<const char*>(s),
          cpp17_input_iterator<const char*>(s + 52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
   }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  test_string<std::string>();
-#if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
-#endif
-
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
-    typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s + 10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s + 10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s + 10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), TIter(s, s + 10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s + 10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s + 10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), w, w + 100);
   }
 #endif
 
   { // test assigning to self
-    typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.assign(s_short.begin(), s_short.end());
     assert(s_short == "123/");
     s_short.assign(s_short.begin() + 2, s_short.end());
     assert(s_short == "3/");
 
     s_long.assign(s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
     s_long.assign(s_long.begin() + 30, s_long.end());
     assert(s_long == "nsectetur/");
   }
 
   { // test assigning a different type
-    typedef std::string S;
     const std::uint8_t p[] = "ABCD";
 
     S s;
     s.assign(p, p + 4);
     assert(s == "ABCD");
   }
 
   { // regression-test assigning to self in sneaky ways
-    std::string sneaky = "hello";
+    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);
   }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+#endif
+
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

#endif
 
   {                                  //  LWG#5579 make sure assign takes the allocators where appropriate
     typedef other_allocator<char> A; // has POCCA --> true
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     testAlloc(S(A(5)), S(A(3)), A(3));
     testAlloc(S(A(5)), S("1"), A());
     testAlloc(S(A(5)), S("1", A(7)), A(7));
     testAlloc(S(A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7));
-    testAlloc(S("12345678901234567890", A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7));
+    testAlloc(S("12345678901234567890", A(5)),
+              S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)),
+              A(7));
   }
 
 #if TEST_STD_VER >= 11
   {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test_assign<S>();
     testAlloc(S(), S(), min_allocator<char>());
     testAlloc(S(), S("12345"), min_allocator<char>());

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

 // iterator insert(const_iterator p, initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  typename S::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

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

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

 // basic_string& operator+=(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #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() {
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), S("12345"), S("1234567890123456789012345"));
   test(S("12345678901234567890"), S("1234567890"), S("123456789012345678901234567890"));
   test(S("12345678901234567890"), S("12345678901234567890"), S("1234567890123456789012345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
-#endif
-
-#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
   { // LWG 2946
     std::string s;
     s += {"abc", 1};
     assert(s.size() == 1);
     assert(s == "a");
   }
 #endif
 

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

 // basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-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");
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
 
     s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   return true;
 }
 
+template <class S>
 TEST_CONSTEXPR_CXX20 void test() {
-  {
-    typedef std::string 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
-  }
-#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;
 }

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

test(S s,
   s.replace(first, last, n2, c);
   LIBCPP_ASSERT(s.__invariants());
   assert(s == expected);
   typename S::size_type rlen = n2;
   assert(s.size() == old_size - xlen + rlen);
 }
 
 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"));
   test(S(""), 0, 0, 20, '3', S("33333333333333333333"));
   test(S("abcde"), 0, 0, 0, '3', S("abcde"));
   test(S("abcde"), 0, 0, 5, '3', S("33333abcde"));
   test(S("abcde"), 0, 0, 10, '3', S("3333333333abcde"));
   test(S("abcde"), 0, 0, 20, '3', S("33333333333333333333abcde"));
TEST_CONSTEXPR_CXX20 bool test0() {
   test(S("abcdefghij"), 1, 0, 0, '3', S("abcdefghij"));
   test(S("abcdefghij"), 1, 0, 5, '3', S("a33333bcdefghij"));
   test(S("abcdefghij"), 1, 0, 10, '3', S("a3333333333bcdefghij"));
   test(S("abcdefghij"), 1, 0, 20, '3', S("a33333333333333333333bcdefghij"));
   test(S("abcdefghij"), 1, 1, 0, '3', S("acdefghij"));
   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"));
   test(S("abcdefghij"), 1, 4, 20, '3', S("a33333333333333333333fghij"));
   test(S("abcdefghij"), 1, 8, 0, '3', S("aj"));
   test(S("abcdefghij"), 1, 8, 5, '3', S("a33333j"));
   test(S("abcdefghij"), 1, 8, 10, '3', S("a3333333333j"));
   test(S("abcdefghij"), 1, 8, 20, '3', S("a33333333333333333333j"));
TEST_CONSTEXPR_CXX20 bool test1() {
   test(S("abcdefghijklmnopqrst"), 10, 5, 0, '3', S("abcdefghijpqrst"));
   test(S("abcdefghijklmnopqrst"), 10, 5, 5, '3', S("abcdefghij33333pqrst"));
   test(S("abcdefghijklmnopqrst"), 10, 5, 10, '3', S("abcdefghij3333333333pqrst"));
   test(S("abcdefghijklmnopqrst"), 10, 5, 20, '3', S("abcdefghij33333333333333333333pqrst"));
   test(S("abcdefghijklmnopqrst"), 10, 9, 0, '3', S("abcdefghijt"));
   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"));
   test(S("abcdefghijklmnopqrst"), 10, 10, 20, '3', S("abcdefghij33333333333333333333"));
   test(S("abcdefghijklmnopqrst"), 19, 0, 0, '3', S("abcdefghijklmnopqrst"));
   test(S("abcdefghijklmnopqrst"), 19, 0, 5, '3', S("abcdefghijklmnopqrs33333t"));
   test(S("abcdefghijklmnopqrst"), 19, 0, 10, '3', S("abcdefghijklmnopqrs3333333333t"));
   test(S("abcdefghijklmnopqrst"), 19, 0, 20, '3', S("abcdefghijklmnopqrs33333333333333333333t"));
   test(S("abcdefghijklmnopqrst"), 19, 1, 0, '3', S("abcdefghijklmnopqrs"));
   test(S("abcdefghijklmnopqrst"), 19, 1, 5, '3', S("abcdefghijklmnopqrs33333"));
   test(S("abcdefghijklmnopqrst"), 19, 1, 10, '3', S("abcdefghijklmnopqrs3333333333"));
   test(S("abcdefghijklmnopqrst"), 19, 1, 20, '3', S("abcdefghijklmnopqrs33333333333333333333"));
   test(S("abcdefghijklmnopqrst"), 20, 0, 0, '3', S("abcdefghijklmnopqrst"));
   test(S("abcdefghijklmnopqrst"), 20, 0, 5, '3', S("abcdefghijklmnopqrst33333"));
   test(S("abcdefghijklmnopqrst"), 20, 0, 10, '3', S("abcdefghijklmnopqrst3333333333"));
   test(S("abcdefghijklmnopqrst"), 20, 0, 20, '3', S("abcdefghijklmnopqrst33333333333333333333"));
+  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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-  }
-#endif
+template <class S>
+TEST_CONSTEXPR_CXX20 void test() {
 
-  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;
 }

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

TEST_CONSTEXPR_CXX20 bool test2() {
   test(S("abcdefghijklmnopqrst"), 20, 0, SV(""), S("abcdefghijklmnopqrst"));
   test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345"), S("abcdefghijklmnopqrst12345"));
   test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
   test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 
   return true;
 }
 
+template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
+  using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
 #if TEST_STD_VER > 17
-    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;
 }

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

TEST_CONSTEXPR_CXX20 bool test56() {
 
   s = s0;
   s.replace(0, 4, arr, 0, std::string::npos); // calls replace(pos1, n1, string("IJKL"), pos, npos)
   assert(s == "IJKL");
 
   return true;
 }
 
-template <class S, class SV>
-TEST_CONSTEXPR_CXX20 bool test() {
+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>();
#if TEST_STD_VER > 17
   static_assert(test49<S, SV>());
   static_assert(test50<S, SV>());
   static_assert(test51<S, SV>());
   static_assert(test52<S, SV>());
   static_assert(test53<S, SV>());
   static_assert(test54<S, SV>());
   static_assert(test55<S, SV>());
 #endif
-
-  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;
 }

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

TEST_CONSTEXPR_CXX20 bool test55() {
   test_npos(S("abcdefghij"), 9, 2, S("12345"), 4, S("abcdefghi5"));
   test_npos(S("abcdefghij"), 9, 2, S("12345"), 5, S("abcdefghi"));
   test_npos(S("abcdefghij"), 9, 2, S("12345"), 6, S("can't happen"));
 
   return true;
 }
 
 template <class S>
-void test() {
+TEST_CONSTEXPR_CXX20 void test() {
   test0<S>();
   test1<S>();
   test2<S>();
   test3<S>();
   test4<S>();
   test5<S>();
   test6<S>();
   test7<S>();
#if TEST_STD_VER > 17
   static_assert(test54<S>());
   static_assert(test55<S>());
 #endif
 }
 
 int main(int, char**) {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 bool test2() {
   test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345"), S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, 0, SV("1234567890"), S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), S("can't happen"));
 
   return true;
 }
 
-template <class S>
+template <class CharT, template <class> class Alloc>
 void test() {
-  {
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
+  using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV = std::basic_string_view<CharT, std::char_traits<CharT> >;
 #if TEST_STD_VER > 17
-    static_assert(test0<S, SV>());
-    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;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp

 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #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> >;
 #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> >;
 #endif
-#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
+#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");
+    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 // TEST_HAS_NO_WIDE_CHARACTERS
-#endif   // TEST_STD_VER >= 11
+#endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     std::basic_stringbuf<char> sb("hello");
     std::basic_istream<char> is(&sb);
     is.exceptions(std::ios_base::eofbit);
 
-    std::basic_string<char> s;
+    S s;
     bool threw = false;
     try {
       std::getline(is, s);
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(!is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == "hello");
   }
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::basic_stringbuf<wchar_t> sb(L"hello");
     std::basic_istream<wchar_t> is(&sb);
     is.exceptions(std::ios_base::eofbit);
 
-    std::basic_string<wchar_t> s;
+    WS s;
     bool threw = false;
     try {
       std::getline(is, s);
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(!is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == L"hello");
   }
 #  endif
 
   {
     std::basic_stringbuf<char> sb;
     std::basic_istream<char> is(&sb);
     is.exceptions(std::ios_base::failbit);
 
-    std::basic_string<char> s;
+    S s;
     bool threw = false;
     try {
       std::getline(is, s);
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == "");
   }
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::basic_stringbuf<wchar_t> sb;
     std::basic_istream<wchar_t> is(&sb);
     is.exceptions(std::ios_base::failbit);
 
-    std::basic_string<wchar_t> s;
+    WS s;
     bool threw = false;
     try {
       std::getline(is, s);
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == L"");
   }
 #  endif
 #endif // TEST_HAS_NO_EXCEPTIONS
+}
+
+int main(int, char**) {
+  test_string<std::allocator>();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator>();
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp

 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #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> >;
 #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> >;
 #endif
-#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
+#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");
+    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 // TEST_HAS_NO_WIDE_CHARACTERS
-#endif   // TEST_STD_VER >= 11
+#endif
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     std::basic_stringbuf<char> sb("hello");
     std::basic_istream<char> is(&sb);
     is.exceptions(std::ios::eofbit);
 
-    std::basic_string<char> s;
+    S s;
     bool threw = false;
     try {
       std::getline(is, s, '\n');
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(!is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == "hello");
   }
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::basic_stringbuf<wchar_t> sb(L"hello");
     std::basic_istream<wchar_t> is(&sb);
     is.exceptions(std::ios::eofbit);
 
-    std::basic_string<wchar_t> s;
+    WS s;
     bool threw = false;
     try {
       std::getline(is, s, L'\n');
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(!is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == L"hello");
   }
 #  endif // TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::basic_stringbuf<char> sb;
     std::basic_istream<char> is(&sb);
     is.exceptions(std::ios::failbit);
 
-    std::basic_string<char> s;
+    S s;
     bool threw = false;
     try {
       std::getline(is, s, '\n');
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == "");
   }
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::basic_stringbuf<wchar_t> sb;
     std::basic_istream<wchar_t> is(&sb);
     is.exceptions(std::ios::failbit);
 
-    std::basic_string<wchar_t> s;
+    WS s;
     bool threw = false;
     try {
       std::getline(is, s, L'\n');
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(is.fail());
     assert(is.eof());
     assert(threw);
     assert(s == L"");
   }
 #  endif // TEST_HAS_NO_WIDE_CHARACTERS
 #endif   // TEST_HAS_NO_EXCEPTIONS
+}
 
+int main(int, char**) {
+  test_string<std::allocator>();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator>();
+#endif
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp

 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+template <template <class> class Alloc>
+void test() {
   {
-    std::string s("initial text");
+    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");
+    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;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp

 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #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
+template <template <class> class Alloc>
+void test() {
   {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
+    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");
+    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;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp

 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main(int, char**) {
+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");
-    std::string s("initial text");
+    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
   {
+    using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
     std::wistringstream in(L"a bc defghij");
-    std::wstring s(L"initial text");
+    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
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     std::stringbuf sb;
     std::istream is(&sb);
     is.exceptions(std::ios::failbit);
 
     bool threw = false;
     try {
-      std::string s;
+      S s;
       is >> s;
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(is.fail());
     assert(is.eof());
     assert(threw);
   }
   {
     std::stringbuf sb;
     std::istream is(&sb);
     is.exceptions(std::ios::eofbit);
 
     bool threw = false;
     try {
-      std::string s;
+      S s;
       is >> s;
     } catch (std::ios::failure const&) {
       threw = true;
     }
 
     assert(!is.bad());
     assert(is.fail());
     assert(is.eof());
     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
+
+int main(int, char**) {
+  test_string<std::allocator>();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator>();
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp

 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**) {
+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> >;
   {
-    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());
-  }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  {
-    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());
-  }
-#endif
-#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;
+    OS 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;
+    OS out;
     S s("some text");
     out.width(12);
     out << s;
     assert(out.good());
     assert("   " + s == out.str());
   }
-#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
+#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> >;
   {
-    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");
+    WOS out;
+    WS 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");
+    WOS out;
+    WS s(L"some text");
     out.width(12);
     out << s;
     assert(out.good());
     assert(L"   " + s == out.str());
   }
-#  endif // TEST_HAS_NO_WIDE_CHARACTERS
-#endif   // TEST_STD_VER >= 11
+#endif
+}
+
+int main(int, char**) {
+  test<std::allocator>();
+
+#if TEST_STD_VER >= 11
+  test<min_allocator>();
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp

TEST_CONSTEXPR_CXX20 void test(S s1, S s2) {
   S s2_ = s2;
   swap(s1, s2);
   LIBCPP_ASSERT(s1.__invariants());
   LIBCPP_ASSERT(s2.__invariants());
   assert(s1 == s2_);
   assert(s2 == s1_);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), S(""));
-    test(S(""), S("12345"));
-    test(S(""), S("1234567890"));
-    test(S(""), S("12345678901234567890"));
-    test(S("abcde"), S(""));
-    test(S("abcde"), S("12345"));
-    test(S("abcde"), S("1234567890"));
-    test(S("abcde"), S("12345678901234567890"));
-    test(S("abcdefghij"), S(""));
-    test(S("abcdefghij"), S("12345"));
-    test(S("abcdefghij"), S("1234567890"));
-    test(S("abcdefghij"), S("12345678901234567890"));
-    test(S("abcdefghijklmnopqrst"), S(""));
-    test(S("abcdefghijklmnopqrst"), S("12345"));
-    test(S("abcdefghijklmnopqrst"), S("1234567890"));
-    test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), S(""));
-    test(S(""), S("12345"));
-    test(S(""), S("1234567890"));
-    test(S(""), S("12345678901234567890"));
-    test(S("abcde"), S(""));
-    test(S("abcde"), S("12345"));
-    test(S("abcde"), S("1234567890"));
-    test(S("abcde"), S("12345678901234567890"));
-    test(S("abcdefghij"), S(""));
-    test(S("abcdefghij"), S("12345"));
-    test(S("abcdefghij"), S("1234567890"));
-    test(S("abcdefghij"), S("12345678901234567890"));
-    test(S("abcdefghijklmnopqrst"), S(""));
-    test(S("abcdefghijklmnopqrst"), S("12345"));
-    test(S("abcdefghijklmnopqrst"), S("1234567890"));
-    test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp

 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(typename S::value_type lhs, S&& rhs, const S& x) {
   assert(lhs + std::move(rhs) == x);
 }
 #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() {
 #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"));
+#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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp

 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(const typename S::value_type* lhs, S&& rhs, const S& x) {
   assert(lhs + std::move(rhs) == x);
 }
 #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() {
 
 #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"));
+#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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp

 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(S&& lhs, typename S::value_type rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
 #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"));
-  }
-#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"));
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test1(S(""), '1', S("1"));
-    test1(S("abcde"), '1', S("abcde1"));
-    test1(S("abcdefghij"), '1', S("abcdefghij1"));
-    test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
-  }
+#if TEST_STD_VER >= 11
+#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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp

 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
 #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() {
 #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"));
+#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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp

 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test3(S&& lhs, S&& rhs, const S& x) {
   assert(std::move(lhs) + std::move(rhs) == x);
 }
 #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() {
 #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"));
+#endif
 
-    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 // 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const typename S::value_type* lhs, const S& rhs, bool x) {
   assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test("", S(""), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test("", S(""), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const typename S::value_type* rhs, bool x) {
   assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), "", 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), "", 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const S& rhs, bool x) {
   assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), S(""), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), S(""), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, SV rhs, bool x) {
   assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(S(""), SV(""), true);
-    test(S(""), SV("abcde"), false);
-    test(S(""), SV("abcdefghij"), false);
-    test(S(""), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), SV(""), false);
-    test(S("abcde"), SV("abcde"), true);
-    test(S("abcde"), SV("abcdefghij"), false);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), SV(""), false);
-    test(S("abcdefghij"), SV("abcde"), false);
-    test(S("abcdefghij"), SV("abcdefghij"), true);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), SV(""), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(SV lhs, const S& rhs, bool x) {
   assert((lhs == rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(SV(""), S(""), 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);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const typename S::value_type* lhs, const S& rhs, bool x) {
   assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test("", S(""), false);
-    test("", S("abcde"), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test("", S(""), false);
-    test("", S("abcde"), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const typename S::value_type* rhs, bool x) {
   assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), "", false);
-    test(S(""), "abcde", 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), "", false);
-    test(S(""), "abcde", 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const S& rhs, bool x) {
   assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), S(""), false);
-    test(S(""), S("abcde"), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), S(""), false);
-    test(S(""), S("abcde"), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, SV rhs, bool x) {
   assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(S(""), SV(""), false);
-    test(S(""), SV("abcde"), false);
-    test(S(""), SV("abcdefghij"), false);
-    test(S(""), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), SV(""), true);
-    test(S("abcde"), SV("abcde"), false);
-    test(S("abcde"), SV("abcdefghij"), false);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), SV(""), true);
-    test(S("abcdefghij"), SV("abcde"), true);
-    test(S("abcdefghij"), SV("abcdefghij"), false);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), SV(""), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(SV lhs, const S& rhs, bool x) {
   assert((lhs > rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(SV(""), S(""), false);
-    test(SV(""), S("abcde"), 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);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const typename S::value_type* lhs, const S& rhs, bool x) {
   assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test("", S(""), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test("", S(""), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const typename S::value_type* rhs, bool x) {
   assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), "", 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), "", 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const S& rhs, bool x) {
   assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), S(""), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), S(""), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, SV rhs, bool x) {
   assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(S(""), SV(""), true);
-    test(S(""), SV("abcde"), false);
-    test(S(""), SV("abcdefghij"), false);
-    test(S(""), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcde"), SV(""), true);
-    test(S("abcde"), SV("abcde"), true);
-    test(S("abcde"), SV("abcdefghij"), false);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghij"), SV(""), true);
-    test(S("abcdefghij"), SV("abcde"), true);
-    test(S("abcdefghij"), SV("abcdefghij"), true);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), false);
-    test(S("abcdefghijklmnopqrst"), SV(""), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(SV lhs, const S& rhs, bool x) {
   assert((lhs >= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(SV(""), S(""), 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);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp

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

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp

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

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp

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

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, SV rhs, bool x) {
   assert((lhs < rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(S(""), SV(""), false);
-    test(S(""), SV("abcde"), true);
-    test(S(""), SV("abcdefghij"), true);
-    test(S(""), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), SV(""), false);
-    test(S("abcde"), SV("abcde"), false);
-    test(S("abcde"), SV("abcdefghij"), true);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), SV(""), false);
-    test(S("abcdefghij"), SV("abcde"), false);
-    test(S("abcdefghij"), SV("abcdefghij"), false);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), SV(""), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(SV lhs, const S& rhs, bool x) {
   assert((lhs < rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(SV(""), S(""), false);
-    test(SV(""), S("abcde"), true);
-    test(SV(""), S("abcdefghij"), true);
-    test(SV(""), S("abcdefghijklmnopqrst"), true);
-    test(SV("abcde"), S(""), 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);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const typename S::value_type* lhs, const S& rhs, bool x) {
   assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test("", S(""), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test("", S(""), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const typename S::value_type* rhs, bool x) {
   assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), "", 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), "", 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, const S& rhs, bool x) {
   assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""), S(""), 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), S(""), 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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(const S& lhs, SV rhs, bool x) {
   assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(S(""), SV(""), true);
-    test(S(""), SV("abcde"), true);
-    test(S(""), SV("abcdefghij"), true);
-    test(S(""), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcde"), SV(""), false);
-    test(S("abcde"), SV("abcde"), true);
-    test(S("abcde"), SV("abcdefghij"), true);
-    test(S("abcde"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghij"), SV(""), false);
-    test(S("abcdefghij"), SV("abcde"), false);
-    test(S("abcdefghij"), SV("abcdefghij"), true);
-    test(S("abcdefghij"), SV("abcdefghijklmnopqrst"), true);
-    test(S("abcdefghijklmnopqrst"), SV(""), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcde"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
-    test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp

 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(SV lhs, const S& rhs, bool x) {
   assert((lhs <= rhs) == x);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test(SV(""), S(""), 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);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp

TEST_CONSTEXPR_CXX20 void test(const S& s) {
   const typename S::value_type* str = s.c_str();
   if (s.size() > 0) {
     assert(T::compare(str, &s[0], s.size()) == 0);
     assert(T::eq(str[s.size()], typename S::value_type()));
   } else
     assert(T::eq(str[0], typename S::value_type()));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(""));
-    test(S("abcde"));
-    test(S("abcdefghij"));
-    test(S("abcdefghijklmnopqrst"));
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""));
-    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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp

TEST_CONSTEXPR_CXX20 void test_nonconst(S& s) {
   typename S::value_type* str = s.data();
   if (s.size() > 0) {
     assert(T::compare(str, &s[0], s.size()) == 0);
     assert(T::eq(str[s.size()], typename S::value_type()));
   } else
     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;
-    test_const(S(""));
-    test_const(S("abcde"));
-    test_const(S("abcdefghij"));
-    test_const(S("abcdefghijklmnopqrst"));
-  }
-#endif
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 #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);
   }
 #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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp

 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, const typename S::allocator_type& a) {
   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;
-    test(S(""), A());
-    test(S("abcde", A(1)), A(1));
-    test(S("abcdefghij", A(2)), A(2));
-    test(S("abcdefghijklmnopqrst", A(3)), A(3));
-  }
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  using S = std::basic_string<char, std::char_traits<char>, Alloc>;
+  test(S(""), Alloc());
+  test(S("abcde", Alloc(a)), Alloc(a));
+  test(S("abcdefghij", Alloc(a)), Alloc(a));
+  test(S("abcdefghijklmnopqrst", Alloc(a)), Alloc(a));
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(1));
+  test_string(test_allocator<char>(2));
+  test_string(test_allocator<char>(3));
 #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(min_allocator<char>());
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp

 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, const typename S::value_type* str, int x) {
   LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
   assert(sign(s.compare(str)) == sign(x));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), "", 0);
-    test(S(""), "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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 bool test56() {
   assert(s.compare(0, 4, arr, 0) > 0);
 
   //  calls compare(size, size, string(arr), 0, npos)
   assert(s.compare(0, 4, arr, 0, std::string::npos) == 0);
 
   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>();
   test3<S, SV>();
   test4<S, SV>();
   test5<S, SV>();
   test6<S, SV>();
   test7<S, SV>();
#if TEST_STD_VER > 17
   static_assert(test53<S, SV>());
   static_assert(test54<S, SV>());
   static_assert(test55<S, SV>());
   static_assert(test56<S, SV>());
 #endif
 }
 
 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;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

TEST_CONSTEXPR_CXX20 void test2() {
   test(S("abcdefghijklmnopqrst"), 20, 1, "abcdefghij", -10);
   test(S("abcdefghijklmnopqrst"), 20, 1, "abcdefghijklmnopqrst", -20);
   test(S("abcdefghijklmnopqrst"), 21, 0, "", 0);
   test(S("abcdefghijklmnopqrst"), 21, 0, "abcde", 0);
   test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 0);
   test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

else if (!TEST_IS_CONSTANT_EVALUATED) {
     } catch (std::out_of_range&) {
       assert(pos1 > s.size());
     }
   }
 #endif
 }
 
 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);
   test(S(""), 0, 0, S("abcdefghijklmnopqrst"), -20);
   test(S(""), 0, 1, S(""), 0);
   test(S(""), 0, 1, S("abcde"), -5);
   test(S(""), 0, 1, S("abcdefghij"), -10);
   test(S(""), 0, 1, S("abcdefghijklmnopqrst"), -20);
TEST_CONSTEXPR_CXX20 bool test0() {
   test(S("abcde"), 5, 0, S(""), 0);
   test(S("abcde"), 5, 0, S("abcde"), -5);
   test(S("abcde"), 5, 0, S("abcdefghij"), -10);
   test(S("abcde"), 5, 0, S("abcdefghijklmnopqrst"), -20);
   test(S("abcde"), 5, 1, S(""), 0);
   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);
   test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0);
   test(S("abcdefghij"), 0, 0, S(""), 0);
   test(S("abcdefghij"), 0, 0, S("abcde"), -5);
   test(S("abcdefghij"), 0, 0, S("abcdefghij"), -10);
   test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), -20);
TEST_CONSTEXPR_CXX20 bool test1() {
   test(S("abcdefghij"), 10, 1, S(""), 0);
   test(S("abcdefghij"), 10, 1, S("abcde"), -5);
   test(S("abcdefghij"), 10, 1, S("abcdefghij"), -10);
   test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), -20);
   test(S("abcdefghij"), 11, 0, S(""), 0);
   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);
   test(S("abcdefghijklmnopqrst"), 0, 0, S("abcdefghijklmnopqrst"), -20);
   test(S("abcdefghijklmnopqrst"), 0, 1, S(""), 1);
   test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), -4);
   test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), -9);
   test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghijklmnopqrst"), -19);
TEST_CONSTEXPR_CXX20 bool test2() {
   test(S("abcdefghijklmnopqrst"), 20, 1, S(""), 0);
   test(S("abcdefghijklmnopqrst"), 20, 1, S("abcde"), -5);
   test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghij"), -10);
   test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), -20);
   test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0);
   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;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-  }
+template <class S>
+void test() {
+
+#if TEST_STD_VER > 17
+  static_assert(test0<S>());
+  static_assert(test1<S>());
+  static_assert(test2<S>());
 #endif
+}
 
+int main(int, char**) {
+  test<std::string>();
 #if TEST_STD_VER >= 11
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.compare(0, 1, {"abc", 1}) < 0);
   }
 #endif
 
-  return true;
-}
-
-int main(int, char**) {
-  test();
-#if TEST_STD_VER > 17
-  static_assert(test());
-#endif
-
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp

TEST_CONSTEXPR_CXX20 void test2() {
   test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghij"), -10);
   test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), -20);
   test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0);
   test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcde"), 0);
   test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghij"), 0);
   test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, 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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp

 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, const S& str, int x) {
   LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
   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;
-    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);
-  }
-#endif
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
+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> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.compare({"abc", 1}) < 0);
   }
 #endif
 
   return true;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp

 }
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(const S& s, SV sv, int x) {
   LIBCPP_ASSERT_NOEXCEPT(s.compare(sv));
   assert(sign(s.compare(sv)) == sign(x));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
-  }
+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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::value_type c, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c));
   assert(s.find_first_not_of(c) == x);
   if (x != S::npos)
     assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    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);
-  }
-#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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), "jtdaefblso", 2);
   test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", S::npos);
   test(S("gprdcokbnjhlsfmtieqa"), "", 0);
   test(S("qjghlnftcaismkropdeb"), "bjaht", 0);
   test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 1);
   test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test3() {
   test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, S::npos);
   test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, S::npos);
   test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, S::npos);
   test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, S::npos);
   test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, S::npos);
   test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), S("jtdaefblso"), 2);
   test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), S::npos);
   test(S("gprdcokbnjhlsfmtieqa"), S(""), 0);
   test(S("qjghlnftcaismkropdeb"), S("bjaht"), 0);
   test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 1);
   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;
-    test0<S>();
-    test1<S>();
-  }
-#endif
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
+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> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.find_first_not_of({"abc", 1}) == 0);
   }
 #endif
 
   return true;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), SV("jtdaefblso"), 2);
   test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), S::npos);
   test(S("gprdcokbnjhlsfmtieqa"), SV(""), 0);
   test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 0);
   test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 1);
   test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, 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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::value_type c, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c));
   assert(s.find_first_of(c) == x);
   if (x != S::npos)
     assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(""), 'e', S::npos);
-    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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), "jtdaefblso", 0);
   test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", 0);
   test(S("gprdcokbnjhlsfmtieqa"), "", S::npos);
   test(S("qjghlnftcaismkropdeb"), "bjaht", 1);
   test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 0);
   test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test3() {
   test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, S::npos);
   test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, S::npos);
   test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, S::npos);
   test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, S::npos);
   test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, S::npos);
   test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), S("jtdaefblso"), 0);
   test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), 0);
   test(S("gprdcokbnjhlsfmtieqa"), S(""), S::npos);
   test(S("qjghlnftcaismkropdeb"), S("bjaht"), 1);
   test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 0);
   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;
-    test0<S>();
-    test1<S>();
-  }
-#endif
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
+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> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.find_first_of({"abc", 1}) == std::string::npos);
   }
 #endif
 
   return true;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), SV("jtdaefblso"), 0);
   test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), 0);
   test(S("gprdcokbnjhlsfmtieqa"), SV(""), S::npos);
   test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 1);
   test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 0);
   test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, 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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::value_type c, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c));
   assert(s.find_last_not_of(c) == x);
   if (x != S::npos)
     assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(""), 'i', S::npos);
-    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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), "jtdaefblso", 9);
   test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", S::npos);
   test(S("gprdcokbnjhlsfmtieqa"), "", 19);
   test(S("qjghlnftcaismkropdeb"), "bjaht", 18);
   test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 17);
   test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test3() {
   test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, 19);
   test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, 19);
   test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, 19);
   test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, 19);
   test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, 7);
   test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), S("jtdaefblso"), 9);
   test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), S::npos);
   test(S("gprdcokbnjhlsfmtieqa"), S(""), 19);
   test(S("qjghlnftcaismkropdeb"), S("bjaht"), 18);
   test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 17);
   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;
-    test0<S>();
-    test1<S>();
-  }
-#endif
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
+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> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.find_last_not_of({"abc", 1}) == s.size() - 1);
   }
 #endif
 
   return true;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), SV("jtdaefblso"), 9);
   test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), S::npos);
   test(S("gprdcokbnjhlsfmtieqa"), SV(""), 19);
   test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 18);
   test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 17);
   test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, 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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::value_type c, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c));
   assert(s.find_last_of(c) == x);
   if (x != S::npos)
     assert(x < s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(""), 'm', S::npos);
-    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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), "jtdaefblso", 8);
   test(S("hkbgspoflt"), "oselktgbcapndfjihrmq", 9);
   test(S("gprdcokbnjhlsfmtieqa"), "", S::npos);
   test(S("qjghlnftcaismkropdeb"), "bjaht", 19);
   test(S("pnalfrdtkqcmojiesbhg"), "hjlcmgpket", 19);
   test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test3() {
   test(S("hdsjbnmlegtkqripacof"), "atgbkrjdsm", 21, 10, 16);
   test(S("pcnedrfjihqbalkgtoms"), "blnrptjgqmaifsdkhoec", 21, 0, S::npos);
   test(S("qjidealmtpskrbfhocng"), "ctpmdahebfqjgknloris", 21, 1, 17);
   test(S("qeindtagmokpfhsclrbj"), "apnkeqthrmlbfodiscgj", 21, 10, 17);
   test(S("kpfegbjhsrnodltqciam"), "jdgictpframeoqlsbknh", 21, 19, 19);
   test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), S("jtdaefblso"), 8);
   test(S("hkbgspoflt"), S("oselktgbcapndfjihrmq"), 9);
   test(S("gprdcokbnjhlsfmtieqa"), S(""), S::npos);
   test(S("qjghlnftcaismkropdeb"), S("bjaht"), 19);
   test(S("pnalfrdtkqcmojiesbhg"), S("hjlcmgpket"), 19);
   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;
-    test0<S>();
-    test1<S>();
-  }
-#endif
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
+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> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.find_last_of({"abc", 1}) == std::string::npos);
   }
 #endif
 
   return true;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("jdmciepkaq"), SV("jtdaefblso"), 8);
   test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), 9);
   test(S("gprdcokbnjhlsfmtieqa"), SV(""), S::npos);
   test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 19);
   test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 19);
   test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 19);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, 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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::value_type c, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.find(c));
   assert(s.find(c) == x);
   if (x != S::npos)
     assert(0 <= x && x + 1 <= s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(""), 'c', S::npos);
-    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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("abcdeabcde"), "abcdeabcde", 0);
   test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", S::npos);
   test(S("abcdeabcdeabcdeabcde"), "", 0);
   test(S("abcdeabcdeabcdeabcde"), "abcde", 0);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 0);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test3() {
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 10, S::npos);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 0, S::npos);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 1, S::npos);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 10, S::npos);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 19, S::npos);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("abcdeabcde"), S("abcdeabcde"), 0);
   test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), S::npos);
   test(S("abcdeabcdeabcdeabcde"), S(""), 0);
   test(S("abcdeabcdeabcdeabcde"), S("abcde"), 0);
   test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 0);
   test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    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 = " !";
     assert(s.find({"abc", 1}) == std::string::npos);
   }
 #endif
 
   return true;

libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test1() {
   test(S("abcdeabcde"), SV("abcdeabcde"), 0);
   test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
   test(S("abcdeabcdeabcdeabcde"), SV(""), 0);
   test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 0);
   test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 0);
   test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, 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_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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::value_type c, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.rfind(c));
   assert(s.rfind(c) == x);
   if (x != S::npos)
     assert(x + 1 <= s.size());
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string 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);
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
 
-    test(S(""), 'b', S::npos);
-    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;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test(const S& s, const typename S::value_type* str, typename S::size_type x) {
   if (x != S::npos) {
     typename S::size_type pos = s.size();
     typename S::size_type n   = S::traits_type::length(str);
     assert(x <= pos && x + n <= s.size());
   }
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test0() {
+TEST_CONSTEXPR_CXX20 void test_string() {
+  {
     test(S(""), "", 0, 0);
     test(S(""), "abcde", 0, S::npos);
     test(S(""), "abcdeabcde", 0, S::npos);
     test(S(""), "abcdeabcdeabcdeabcde", 0, S::npos);
     test(S(""), "", 1, 0);
     test(S(""), "abcde", 1, S::npos);
     test(S(""), "abcdeabcde", 1, S::npos);
     test(S(""), "abcdeabcdeabcdeabcde", 1, S::npos);
     test(S("abcde"), "", 0, 0);
     test(S("abcde"), "abcde", 0, 0);
     test(S("abcde"), "abcdeabcde", 0, S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", 0, S::npos);
     test(S("abcde"), "", 1, 1);
     test(S("abcde"), "abcde", 1, 0);
     test(S("abcde"), "abcdeabcde", 1, S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", 1, S::npos);
     test(S("abcde"), "", 2, 2);
     test(S("abcde"), "abcde", 2, 0);
     test(S("abcde"), "abcdeabcde", 2, S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", 2, S::npos);
     test(S("abcde"), "", 4, 4);
     test(S("abcde"), "abcde", 4, 0);
     test(S("abcde"), "abcdeabcde", 4, S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", 4, S::npos);
     test(S("abcde"), "", 5, 5);
     test(S("abcde"), "abcde", 5, 0);
     test(S("abcde"), "abcdeabcde", 5, S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", 5, S::npos);
     test(S("abcde"), "", 6, 5);
     test(S("abcde"), "abcde", 6, 0);
     test(S("abcde"), "abcdeabcde", 6, S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", 6, S::npos);
     test(S("abcdeabcde"), "", 0, 0);
     test(S("abcdeabcde"), "abcde", 0, 0);
     test(S("abcdeabcde"), "abcdeabcde", 0, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 0, S::npos);
     test(S("abcdeabcde"), "", 1, 1);
     test(S("abcdeabcde"), "abcde", 1, 0);
     test(S("abcdeabcde"), "abcdeabcde", 1, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 1, S::npos);
     test(S("abcdeabcde"), "", 5, 5);
     test(S("abcdeabcde"), "abcde", 5, 5);
     test(S("abcdeabcde"), "abcdeabcde", 5, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 5, S::npos);
     test(S("abcdeabcde"), "", 9, 9);
     test(S("abcdeabcde"), "abcde", 9, 5);
     test(S("abcdeabcde"), "abcdeabcde", 9, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 9, S::npos);
     test(S("abcdeabcde"), "", 10, 10);
     test(S("abcdeabcde"), "abcde", 10, 5);
     test(S("abcdeabcde"), "abcdeabcde", 10, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 10, S::npos);
     test(S("abcdeabcde"), "", 11, 10);
     test(S("abcdeabcde"), "abcde", 11, 5);
     test(S("abcdeabcde"), "abcdeabcde", 11, 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", 11, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "", 0, 0);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 0, 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 0, 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0, 0);
     test(S("abcdeabcdeabcdeabcde"), "", 1, 1);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 1, 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 1, 0);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 1, 0);
     test(S("abcdeabcdeabcdeabcde"), "", 10, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 10, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 10, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 10, 0);
     test(S("abcdeabcdeabcdeabcde"), "", 19, 19);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 19, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 19, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 19, 0);
     test(S("abcdeabcdeabcdeabcde"), "", 20, 20);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 20, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 20, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 0);
     test(S("abcdeabcdeabcdeabcde"), "", 21, 20);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 21, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 0);
   }
-
-template <class S>
-TEST_CONSTEXPR_CXX20 void test1() {
+  {
     test(S(""), "", 0);
     test(S(""), "abcde", S::npos);
     test(S(""), "abcdeabcde", S::npos);
     test(S(""), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcde"), "", 5);
     test(S("abcde"), "abcde", 0);
     test(S("abcde"), "abcdeabcde", S::npos);
     test(S("abcde"), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcdeabcde"), "", 10);
     test(S("abcdeabcde"), "abcde", 5);
     test(S("abcdeabcde"), "abcdeabcde", 0);
     test(S("abcdeabcde"), "abcdeabcdeabcdeabcde", S::npos);
     test(S("abcdeabcdeabcdeabcde"), "", 20);
     test(S("abcdeabcdeabcdeabcde"), "abcde", 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 10);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
   }
-
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-  }
+
+TEST_CONSTEXPR_CXX20 bool tests() {
+  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;
 }
 
 int main(int, char**) {
-  test();
+  tests();
 #if TEST_STD_VER > 17
-  static_assert(test());
+  static_assert(tests());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test3() {
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcde", 21, 10, 10);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 0, 20);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 1, 15);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 10, 10);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 19, 0);
   test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp

 TEST_CONSTEXPR_CXX20 void test(const S& s, const S& str, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
   assert(s.rfind(str) == x);
   if (x != S::npos)
     assert(0 <= x && x + str.size() <= s.size());
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test0() {
+TEST_CONSTEXPR_CXX20 void test_string() {
+  {
     test(S(""), S(""), 0, 0);
     test(S(""), S("abcde"), 0, S::npos);
     test(S(""), S("abcdeabcde"), 0, S::npos);
     test(S(""), S("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S(""), S(""), 1, 0);
     test(S(""), S("abcde"), 1, S::npos);
     test(S(""), S("abcdeabcde"), 1, S::npos);
     test(S(""), S("abcdeabcdeabcdeabcde"), 1, S::npos);
     test(S("abcde"), S(""), 0, 0);
     test(S("abcde"), S("abcde"), 0, 0);
     test(S("abcde"), S("abcdeabcde"), 0, S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S("abcde"), S(""), 1, 1);
     test(S("abcde"), S("abcde"), 1, 0);
     test(S("abcde"), S("abcdeabcde"), 1, S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), 1, S::npos);
     test(S("abcde"), S(""), 2, 2);
     test(S("abcde"), S("abcde"), 2, 0);
     test(S("abcde"), S("abcdeabcde"), 2, S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), 2, S::npos);
     test(S("abcde"), S(""), 4, 4);
     test(S("abcde"), S("abcde"), 4, 0);
     test(S("abcde"), S("abcdeabcde"), 4, S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), 4, S::npos);
     test(S("abcde"), S(""), 5, 5);
     test(S("abcde"), S("abcde"), 5, 0);
     test(S("abcde"), S("abcdeabcde"), 5, S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), 5, S::npos);
     test(S("abcde"), S(""), 6, 5);
     test(S("abcde"), S("abcde"), 6, 0);
     test(S("abcde"), S("abcdeabcde"), 6, S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), 6, S::npos);
     test(S("abcdeabcde"), S(""), 0, 0);
     test(S("abcdeabcde"), S("abcde"), 0, 0);
     test(S("abcdeabcde"), S("abcdeabcde"), 0, 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S("abcdeabcde"), S(""), 1, 1);
     test(S("abcdeabcde"), S("abcde"), 1, 0);
     test(S("abcdeabcde"), S("abcdeabcde"), 1, 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), 1, S::npos);
     test(S("abcdeabcde"), S(""), 5, 5);
     test(S("abcdeabcde"), S("abcde"), 5, 5);
     test(S("abcdeabcde"), S("abcdeabcde"), 5, 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), 5, S::npos);
     test(S("abcdeabcde"), S(""), 9, 9);
     test(S("abcdeabcde"), S("abcde"), 9, 5);
     test(S("abcdeabcde"), S("abcdeabcde"), 9, 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), 9, S::npos);
     test(S("abcdeabcde"), S(""), 10, 10);
     test(S("abcdeabcde"), S("abcde"), 10, 5);
     test(S("abcdeabcde"), S("abcdeabcde"), 10, 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), 10, S::npos);
     test(S("abcdeabcde"), S(""), 11, 10);
     test(S("abcdeabcde"), S("abcde"), 11, 5);
     test(S("abcdeabcde"), S("abcdeabcde"), 11, 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), 11, S::npos);
     test(S("abcdeabcdeabcdeabcde"), S(""), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), S(""), 1, 1);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 1, 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 1, 0);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 1, 0);
     test(S("abcdeabcdeabcdeabcde"), S(""), 10, 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 10, 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 10, 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 10, 0);
     test(S("abcdeabcdeabcdeabcde"), S(""), 19, 19);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 19, 15);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 19, 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 19, 0);
     test(S("abcdeabcdeabcdeabcde"), S(""), 20, 20);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 20, 15);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 20, 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 20, 0);
     test(S("abcdeabcdeabcdeabcde"), S(""), 21, 20);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 21, 15);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 21, 10);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 21, 0);
   }
-
-template <class S>
-TEST_CONSTEXPR_CXX20 void test1() {
+  {
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), S::npos);
     test(S(""), S("abcdeabcde"), S::npos);
     test(S(""), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcde"), S(""), 5);
     test(S("abcde"), S("abcde"), 0);
     test(S("abcde"), S("abcdeabcde"), S::npos);
     test(S("abcde"), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcde"), S(""), 10);
     test(S("abcdeabcde"), S("abcde"), 5);
     test(S("abcdeabcde"), S("abcdeabcde"), 0);
     test(S("abcdeabcde"), S("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcdeabcdeabcde"), S(""), 20);
     test(S("abcdeabcdeabcdeabcde"), S("abcde"), 15);
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcde"), 10);
     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;
-    test0<S>();
-    test1<S>();
-  }
-#endif
 
+TEST_CONSTEXPR_CXX20 bool tests() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
+  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;
 }
 
 int main(int, char**) {
-  test();
+  tests();
 #if TEST_STD_VER > 17
-  static_assert(test());
+  static_assert(tests());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp

 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void test(const S& s, SV sv, typename S::size_type x) {
   LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv));
   assert(s.rfind(sv) == x);
   if (x != S::npos)
     assert(0 <= x && x + sv.size() <= s.size());
 }
 
-template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void test0() {
+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, 0);
     test(S(""), SV("abcde"), 0, S::npos);
     test(S(""), SV("abcdeabcde"), 0, S::npos);
     test(S(""), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S(""), SV(""), 1, 0);
     test(S(""), SV("abcde"), 1, S::npos);
     test(S(""), SV("abcdeabcde"), 1, S::npos);
     test(S(""), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
     test(S("abcde"), SV(""), 0, 0);
     test(S("abcde"), SV("abcde"), 0, 0);
     test(S("abcde"), SV("abcdeabcde"), 0, S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S("abcde"), SV(""), 1, 1);
     test(S("abcde"), SV("abcde"), 1, 0);
     test(S("abcde"), SV("abcdeabcde"), 1, S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
     test(S("abcde"), SV(""), 2, 2);
     test(S("abcde"), SV("abcde"), 2, 0);
     test(S("abcde"), SV("abcdeabcde"), 2, S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 2, S::npos);
     test(S("abcde"), SV(""), 4, 4);
     test(S("abcde"), SV("abcde"), 4, 0);
     test(S("abcde"), SV("abcdeabcde"), 4, S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 4, S::npos);
     test(S("abcde"), SV(""), 5, 5);
     test(S("abcde"), SV("abcde"), 5, 0);
     test(S("abcde"), SV("abcdeabcde"), 5, S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 5, S::npos);
     test(S("abcde"), SV(""), 6, 5);
     test(S("abcde"), SV("abcde"), 6, 0);
     test(S("abcde"), SV("abcdeabcde"), 6, S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), 6, S::npos);
     test(S("abcdeabcde"), SV(""), 0, 0);
     test(S("abcdeabcde"), SV("abcde"), 0, 0);
     test(S("abcdeabcde"), SV("abcdeabcde"), 0, 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0, S::npos);
     test(S("abcdeabcde"), SV(""), 1, 1);
     test(S("abcdeabcde"), SV("abcde"), 1, 0);
     test(S("abcdeabcde"), SV("abcdeabcde"), 1, 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 1, S::npos);
     test(S("abcdeabcde"), SV(""), 5, 5);
     test(S("abcdeabcde"), SV("abcde"), 5, 5);
     test(S("abcdeabcde"), SV("abcdeabcde"), 5, 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 5, S::npos);
     test(S("abcdeabcde"), SV(""), 9, 9);
     test(S("abcdeabcde"), SV("abcde"), 9, 5);
     test(S("abcdeabcde"), SV("abcdeabcde"), 9, 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 9, S::npos);
     test(S("abcdeabcde"), SV(""), 10, 10);
     test(S("abcdeabcde"), SV("abcde"), 10, 5);
     test(S("abcdeabcde"), SV("abcdeabcde"), 10, 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 10, S::npos);
     test(S("abcdeabcde"), SV(""), 11, 10);
     test(S("abcdeabcde"), SV("abcde"), 11, 5);
     test(S("abcdeabcde"), SV("abcdeabcde"), 11, 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), 11, S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0, 0);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 1, 1);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 1, 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 1, 0);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 1, 0);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 10, 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 10, 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 10, 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 10, 0);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 19, 19);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 19, 15);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 19, 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 19, 0);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 20, 20);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 20, 15);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 20, 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 20, 0);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 21, 20);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 21, 15);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 21, 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 21, 0);
   }
 
-template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void test1() {
+  {
     test(S(""), SV(""), 0);
     test(S(""), SV("abcde"), S::npos);
     test(S(""), SV("abcdeabcde"), S::npos);
     test(S(""), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcde"), SV(""), 5);
     test(S("abcde"), SV("abcde"), 0);
     test(S("abcde"), SV("abcdeabcde"), S::npos);
     test(S("abcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcde"), SV(""), 10);
     test(S("abcdeabcde"), SV("abcde"), 5);
     test(S("abcdeabcde"), SV("abcdeabcde"), 0);
     test(S("abcdeabcde"), SV("abcdeabcdeabcdeabcde"), S::npos);
     test(S("abcdeabcdeabcdeabcde"), SV(""), 20);
     test(S("abcdeabcdeabcdeabcde"), SV("abcde"), 15);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcde"), 10);
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
   }
-
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-  }
+
+TEST_CONSTEXPR_CXX20 bool tests() {
+  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;
 }
 
 int main(int, char**) {
-  test();
+  tests();
 #if TEST_STD_VER > 17
-  static_assert(test());
+  static_assert(tests());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
-// An string is a contiguous container
+// A string is a contiguous container
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 TEST_CONSTEXPR_CXX20 void test_contiguous(const C& c) {
   for (std::size_t i = 0; i < c.size(); ++i)
     assert(*(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string(const Alloc& a) {
+  typedef std::basic_string<char, std::char_traits<char>, Alloc> S;
+
   {
-    typedef std::string S;
     test_contiguous(S());
     test_contiguous(S("1"));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890"));
   }
-
   {
-    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_contiguous(S(Alloc()));
+    test_contiguous(S("1", Alloc()));
+    test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc()));
   }
-#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_contiguous(S(Alloc(a)));
+    test_contiguous(S("1", Alloc(a)));
+    test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", Alloc(a)));
   }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string(std::allocator<char>());
+  test_string(test_allocator<char>());
+  test_string(test_allocator<char>(3));
+#if TEST_STD_VER >= 11
+  test_string(min_allocator<char>());
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp

 
 // constexpr bool starts_with(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    S s1{};
-    S s2{"abcde", 5};
+template <class S>
+constexpr void test_string() {
 
-    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'));
-  }
 
+constexpr bool test() {
+  test_string<std::string>();
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp

 
 // constexpr bool starts_with(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #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>
+constexpr void test_string() {
 
-    LIBCPP_ASSERT_NOEXCEPT(s0.starts_with(""));
 
-    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(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"));
-  }
 
+constexpr bool test() {
+  test_string<std::string>();
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 
 // constexpr bool starts_with(string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-constexpr bool test() {
-  typedef std::string S;
-  typedef std::string_view SV;
+template <class CharT, template <class> class Alloc>
+constexpr 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 };
constexpr void test_string() {
 
   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));
+}
+
+constexpr bool test() {
+  test_string<char, std::allocator>();
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/utils/data/ignore_format.txt

 libcxx/test/std/re/re.traits/lookup_classname.pass.cpp
 libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp
 libcxx/test/std/re/re.traits/transform.pass.cpp
 libcxx/test/std/re/re.traits/transform_primary.pass.cpp
 libcxx/test/std/re/re.traits/translate_nocase.pass.cpp
 libcxx/test/std/re/re.traits/translate.pass.cpp
 libcxx/test/std/re/re.traits/types.pass.cpp
 libcxx/test/std/re/re.traits/value.pass.cpp
-libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
 libcxx/test/std/thread/futures/futures.async/async.pass.cpp
 libcxx/test/std/thread/futures/futures.async/async_race.38682.pass.cpp
 libcxx/test/std/thread/futures/futures.async/async_race.pass.cpp
 libcxx/test/std/thread/futures/futures.async/async.verify.cpp
 libcxx/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
 libcxx/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
 libcxx/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
 libcxx/test/std/thread/futures/futures.errors/future_category.pass.cpp