[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

172

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

61

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

40–41

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

44–45

Same: conserve formatting.

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

85–88

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

172

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

68–69

TODO: check this refactoring.

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

79–80

TODO: check this one.

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

90

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

22–23

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/std/strings/basic.string/string.capacity/resize_and_overwrite.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
 //
 //===----------------------------------------------------------------------===//
 
constexpr void test_truncating(std::size_t o, size_t N) {
   assert(N < o);
   auto s = S(o, 'a');
   s.resize_and_overwrite(N, [&](auto* p, auto n) {
     assert(n == N);
     LIBCPP_ASSERT(s.size() == n);
     LIBCPP_ASSERT(s.begin().base() == p);
     assert(std::all_of(p, p + n, [](auto ch) { return ch == 'a'; }));
     p[n - 1] = 'b';
-    p[n] = 'c'; // will be overwritten
+    p[n]     = 'c'; // will be overwritten
     return n;
   });
   const S expected = S(N - 1, 'a') + S(1, 'b');
   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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 

 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(SV sv, std::size_t pos, std::size_t n)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    typedef typename S::size_type Size;
-    if (pos <= sv.size())
-    {
-        S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
-        LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= sv.size());
-        std::size_t rlen = std::min(sv.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(SV sv, std::size_t pos, std::size_t n) {
+  if (pos <= sv.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::size_type Size;
-    if (pos <= sv.size())
-    {
-        S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
-        LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= sv.size());
-        std::size_t rlen = std::min(sv.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == a);
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a) {
+  if (pos <= sv.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #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 CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A  = Alloc<CharT>;
+  using S  = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  using SV = std::basic_string_view< CharT, std::char_traits<CharT> >;
 
-    test<S,SV>(SV(), 0, 0);
-    test<S,SV>(SV(), 0, 1);
-    test<S,SV>(SV(), 1, 0);
-    test<S,SV>(SV(), 1, 1);
-    test<S,SV>(SV(), 1, 2);
-    test<S,SV>(SV("1"), 0, 0);
-    test<S,SV>(SV("1"), 0, 1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   0);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,   1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50,  10);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100);
+  test<S, SV>(SV(), 0, 0);
+  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, 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());
 
-#if TEST_STD_VER >= 11
+TEST_CONSTEXPR_CXX20 bool test() {
   {
-    typedef min_allocator<char> A;
+    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;
+    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);
+    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<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));
   }
+
+#if TEST_STD_VER >= 11
+  test_string<char, min_allocator>();
 #endif
   {
     typedef std::string S;
     typedef std::string_view SV;
-    S s = "ABCD";
-    SV sv = "EFGH";
+    S s        = "ABCD";
+    SV sv      = "EFGH";
     char arr[] = "IJKL";
 
-    S s1("CDEF", 4);    // calls ctor(const char *, len)
+    S s1("CDEF", 4); // calls ctor(const char *, len)
     assert(s1 == "CDEF");
 
     S s2("QRST", 0, 3); // calls ctor(string("QRST", pos, len)
     assert(s2 == "QRS");
 
-    S s3(sv, 0, std::string::npos);   // calls ctor(T, pos, npos)
+    S s3(sv, 0, std::string::npos); // calls ctor(T, pos, npos)
     assert(s3 == sv);
 
-    S s4(sv, 0, 3);   // calls ctor(T, pos, len)
+    S s4(sv, 0, 3); // calls ctor(T, pos, len)
     assert(s4 == "EFG");
 
-    S s5(arr, 0, 2);     // calls ctor(const char *, len)
+    S s5(arr, 0, 2); // calls ctor(const char *, len)
     assert(s5 == "IJ");
 
-    S s6(arr, 0);     // calls ctor(const char *, len)
+    S s6(arr, 0); // calls ctor(const char *, len)
     assert(s6 == "");
 
-    S s7(s.data(), 2);     // calls ctor(const char *, len)
+    S s7(s.data(), 2); // calls ctor(const char *, len)
     assert(s7 == "AB");
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // basic_string(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s1)
-{
-    S s2 = s1;
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == s1.get_allocator());
+TEST_CONSTEXPR_CXX20 void test(S s1) {
 }
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(A()));
+  test(S("1", A()));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    using A = test_allocator<char>;
+    using S = std::basic_string<char, std::char_traits<char>, A>;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
   }
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(A{}));
-    test(S("1", A()));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-  }
+  test_string<char, min_allocator>();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // basic_string(const basic_string& str, const Allocator& alloc); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct alloc_imp {
-    bool active;
 
-    TEST_CONSTEXPR alloc_imp() : active(true) {}
 
-    template <class T>
-    T* allocate(std::size_t n)
-    {
-        if (active)
-            return static_cast<T*>(std::malloc(n * sizeof(T)));
-        else
-            throw std::bad_alloc();
-    }
+  T* allocate(std::size_t n) {
 
-    template <class T>
-    void deallocate(T* p, std::size_t) { std::free(p); }
-    void activate  ()                  { active = true; }
-    void deactivate()                  { active = false; }
+  void deallocate(T* p, std::size_t) {
+    std::free(p);
+  }
+  void activate() { active = true; }
+  void deactivate() { active = false; }
 };
 
 template <class T>
 struct poca_alloc {
-    typedef T value_type;
-    typedef std::true_type propagate_on_container_copy_assignment;
 
-    alloc_imp *imp;
+  alloc_imp* imp;
 
-    TEST_CONSTEXPR poca_alloc(alloc_imp *imp_) : imp (imp_) {}
+  TEST_CONSTEXPR poca_alloc(alloc_imp* imp_) : imp(imp_) {}
 
-    template <class U>
-    TEST_CONSTEXPR poca_alloc(const poca_alloc<U>& other) : imp(other.imp) {}
 
-    T*   allocate  (std::size_t n)       { return imp->allocate<T>(n);}
-    void deallocate(T* p, std::size_t n) { imp->deallocate(p, n); }
+  T* allocate(std::size_t n) { return imp->allocate<T>(n); }
 };
 
 template <typename T, typename U>
-bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
-{
-    return lhs.imp == rhs.imp;
+bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs) {
 }
 
 template <typename T, typename U>
-bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
-{
-    return lhs.imp != rhs.imp;
+bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs) {
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void test_assign(S &s1, const S& s2)
-{
-    try { s1 = s2; }
-    catch ( std::bad_alloc &) { return; }
-    assert(false);
+TEST_CONSTEXPR_CXX20 void test_assign(S& s1, const S& s2) {
+  try {
+    s1 = s2;
+  } catch (std::bad_alloc&) {
+    return;
+  }
 }
 #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 void test(S s1, const typename S::allocator_type& a) {
 }
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(), A());
+  test(S("1"), A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    using A = test_allocator<char>;
+    using S = std::basic_string<char, std::char_traits<char>, A>;
     test(S(), A(3));
     test(S("1"), A(5));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
   }
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(), A());
-    test(S("1"), A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-  }
+  test_string<char, min_allocator>();
 
-#ifndef TEST_HAS_NO_EXCEPTIONS
+#  ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
-    const char * p1 = "This is my first string";
-    const char * p2 = "This is my second string";
+    const char* p1 = "This is my first string";
+    const char* p2 = "This is my second string";
 
     alloc_imp imp1;
     alloc_imp imp2;
     S s1(p1, A(&imp1));
     S s2(p2, A(&imp2));
 
     assert(s1 == p1);
     assert(s2 == p2);
 
     imp2.deactivate();
     test_assign(s1, s2);
     assert(s1 == p1);
     assert(s2 == p2);
   }
-#endif
+#  endif
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class InputIterator>
 //   basic_string(InputIterator begin, InputIterator end,
 //   const Allocator& a = Allocator()); // constexpr since C++20
 
-
 #include <string>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class It>
-TEST_CONSTEXPR_CXX20 void
-test(It first, It last)
-{
-    typedef typename std::iterator_traits<It>::value_type charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(first, last);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
-    unsigned i = 0;
-    for (It it = first; it != last;) {
-        assert(s2[i] == *it);
-        ++it;
-        ++i;
-    }
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(It first, It last) {
 }
 
 template <class It, class A>
-TEST_CONSTEXPR_CXX20 void
-test(It first, It last, const A& a)
-{
-    typedef typename std::iterator_traits<It>::value_type charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(first, last, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
-    unsigned i = 0;
-    for (It it = first; it != last;) {
-        assert(s2[i] == *it);
-        ++it;
-        ++i;
-    }
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(It first, It last, const A& a) {
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    const char* s = "12345678901234567890123456789012345678901234567890";
+template <class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const Alloc& a) {
 
-    test(s, s);
-    test(s, s, A(2));
+  test(s, s, Alloc(a));
 
-    test(s, s+1);
-    test(s, s+1, A(2));
+  test(s, s + 1);
+  test(s, s + 1, Alloc(a));
 
-    test(s, s+10);
-    test(s, s+10, A(2));
+  test(s, s + 10);
+  test(s, s + 10, Alloc(a));
 
-    test(s, s+50);
-    test(s, s+50, A(2));
+  test(s, s + 50);
+  test(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(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(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), 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(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), 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(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), 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<test_allocator<char> >(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test<min_allocator<char> >(min_allocator<char>());
 #endif
   {
-      static_assert((!std::is_constructible<std::string, std::string,
-                                            std::string>::value),
-                    "");
-      static_assert(
-          (!std::is_constructible<std::string, std::string, std::string,
-                                  std::allocator<char> >::value),
-          "");
+    static_assert((!std::is_constructible<std::string, std::string, std::string>::value), "");
+    static_assert((!std::is_constructible<std::string, std::string, std::string, std::allocator<char> >::value), "");
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <string>
 
 // basic_string(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #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 void test(S s0) {
 }
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(A{}));
+  test(S("1", A()));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    using A = test_allocator<char>;
+    using S = std::basic_string<char, std::char_traits<char>, A>;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
   }
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(A{}));
-    test(S("1", A()));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-  }
+  test_string<char, min_allocator>();
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class StringView, class Allocator, class = void>
-struct CanDeduce : std::false_type { };
+struct CanDeduce : std::false_type {};
 
 template <class StringView, class Allocator>
 struct CanDeduce<StringView, Allocator, decltype((void)
   std::basic_string{std::declval<StringView>(), std::declval<Allocator>()}
 )> : std::true_type { };
 
-struct NotAnAllocator { };
-static_assert( CanDeduce<std::string_view, std::allocator<char>>::value);
+struct NotAnAllocator {};
+static_assert(CanDeduce<std::string_view, std::allocator<char> >::value);
 static_assert(!CanDeduce<std::string_view, NotAnAllocator>::value);
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const std::basic_string_view<CharT, std::char_traits<CharT> > sv,
+                               const std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> > s1) {
+  using S = decltype(s1); // what type did we get?
+  static_assert(std::is_same_v<typename S::value_type, CharT>, "");
+  static_assert(std::is_same_v<typename S::traits_type, std::char_traits<CharT> >, "");
+  static_assert(std::is_same_v<typename S::allocator_type, Alloc<CharT> >, "");
+  assert(s1.size() == sv.size());
+  assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1(sv);
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
-
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, std::allocator<char>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, test_allocator<wchar_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<wchar_t, test_allocator>(std::move(sv), std::move(s1));
   }
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, min_allocator<char8_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char8_t, min_allocator>(std::move(sv), std::move(s1));
   }
 #endif
   {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, min_allocator<char16_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char16_t, min_allocator>(std::move(sv), std::move(s1));
   }
   {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, explicit_allocator<char32_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
-    assert(s1.size() == sv.size());
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char32_t, explicit_allocator>(std::move(sv), std::move(s1));
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class StringView, class Size, class Allocator, class = void>
-struct CanDeduce : std::false_type { };
+struct CanDeduce : std::false_type {};
 
 template <class StringView, class Size, class Allocator>
 struct CanDeduce<StringView, Size, Allocator, decltype((void)
   std::basic_string{std::declval<StringView>(), std::declval<Size>(), std::declval<Size>(), std::declval<Allocator>()}
 )> : std::true_type { };
 
-struct NotAnAllocator { };
-static_assert( CanDeduce<std::string_view, std::size_t, std::allocator<char>>::value);
+struct NotAnAllocator {};
+static_assert(CanDeduce<std::string_view, std::size_t, std::allocator<char> >::value);
 static_assert(!CanDeduce<std::string_view, std::size_t, NotAnAllocator>::value);
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const std::basic_string_view<CharT, std::char_traits<CharT> > sv,
+                               const std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> > s1) {
+  using S = decltype(s1); // what type did we get?
+  static_assert(std::is_same_v<typename S::value_type, CharT>, "");
+  static_assert(std::is_same_v<typename S::traits_type, std::char_traits<CharT> >, "");
+  static_assert(std::is_same_v<typename S::allocator_type, Alloc<CharT> >, "");
+  assert(s1.size() == 4);
+  assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
 
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4, std::allocator<char>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char, std::allocator>(std::move(sv), std::move(s1));
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, 0, 4, test_allocator<wchar_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<wchar_t, test_allocator>(std::move(sv), std::move(s1));
   }
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char8_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char8_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char8_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char8_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char8_t, min_allocator>(std::move(sv), std::move(s1));
   }
 #endif
   {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char16_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char16_t, min_allocator>(std::move(sv), std::move(s1));
   }
   {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, 0, 4, explicit_allocator<char32_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
-    assert(s1.size() == 4);
-    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+    test<char32_t, explicit_allocator>(std::move(sv), std::move(s1));
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class InputIterator>
 //   basic_string& assign(InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
-TEST_CONSTEXPR_CXX20 void
-test(S s, It first, It last, S expected)
-{
-    s.assign(first, last);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, It first, It last, S expected) {
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-struct Widget { operator char() const { throw 42; } };
+struct Widget {
+  operator char() const { throw 42; }
+};
 
 template <class S, class It>
-void
-test_exceptions(S s, It first, It last)
-{
-    S original = s;
-    typename S::iterator begin = s.begin();
-    typename S::iterator end = s.end();
+void test_exceptions(S s, It first, It last) {
+  S original                 = s;
+  typename S::iterator end   = s.end();
 
-    try {
-        s.assign(first, last);
-        assert(false);
-    } catch (...) {}
+  } catch (...) {
+  }
 
-    // Part of "no effects" is that iterators and pointers
-    // into the string must not have been invalidated.
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == original);
-    assert(s.begin() == begin);
-    assert(s.end() == end);
 }
 #endif
 
 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(), 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("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("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("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 + 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),
+  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),
+  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),
+  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),
+  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),
+  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),
+  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>>>();
+  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(), IIter(TIter(s, s + 10, 4, TIter::TAIncrement)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s + 10, 5, TIter::TADereference)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s + 10, 6, TIter::TAComparison)), IIter(TIter()));
 
-    test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
-    test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
-    test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
+    test_exceptions(S(), TIter(s, s + 10, 4, TIter::TAIncrement), TIter());
+    test_exceptions(S(), TIter(s, s + 10, 5, TIter::TADereference), TIter());
+    test_exceptions(S(), TIter(s, s + 10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
-    test_exceptions(S(), w, w+100);
+    test_exceptions(S(), w, w + 100);
   }
 #endif
 
   { // test assigning to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
#endif
     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";
+    typedef std::string S;
+    S sneaky = "hello";
     sneaky.resize(sneaky.capacity(), 'x');
-    std::string expected = sneaky + std::string(1, '\0');
+    S expected = sneaky + S(1, '\0');
     test(sneaky, sneaky.data(), sneaky.data() + sneaky.size() + 1, expected);
   }
   return true;
 }
 
-int main(int, char**)
-{
+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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // allocator_type get_allocator() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #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 void test(const S& s, const typename S::allocator_type& a) {
 }
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+  test(S(""), A());
+  test(S("abcde", A()), A());
+  test(S("abcdefghij", A()), A());
+  test(S("abcdefghijklmnopqrst", A()), A());
+}
+
 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));
   }
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(""), A());
-    test(S("abcde", A()), A());
-    test(S("abcdefghij", A()), A());
-    test(S("abcdefghijklmnopqrst", A()), A());
-  }
+  test_string<char, min_allocator>();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }