[String] Allow fancy pointer as pointer type of basic_string allocator

[ldionne]

Summary

Currently, basic_string does not support custom allocators which use fancy pointers that are not trivially constructible and destructible as the pointer type. This is due to requirements of the internal string representation, __rep. In order to use a pointer type which is not trivially constructible, __rep should:

• be a literal type (required by the implementation). This requires that __rep has at least one constexpr constructor and that its destructor is trivial.
• provide an explicit constructor, copy constructor and copy assignment operator (default special member functions are deleted since __long, a variant member of __rep, is not trivially constructible as it contains a fancy pointer as a member variable).

This change allows the use of fancy pointers which are not trivially constructible by adding an explicit and constexpr constructor, copy constructor and copy assignment operator. It also adds a static assert which will fail if the fancy pointer is not trivially destructible.

Addresses bug report: https://bugs.llvm.org/show_bug.cgi?id=20508

Implementation details:

Constant evaluation: From above, we have the requirement that __rep has at least one constexpr constructor. This means that we cannot use non-const functions such as memcpy or memset in the copy constructor / copy assigment operators. Additionally, the active element of a union is not allowed to be changed inside a constexpr constructor. Since during constant evaluation, short string optimization is disabled for basic_string, the active element of the __rep union can be __l and we can manually copy values from other.__l to this->__l.

Non-constant evaluation: During non-constant evaluation, the active member of __rep can be __rep.__s or __rep.__l i.e. a short or long string. In this case, we rely on type punning in the copy constructor and copy assignment operators to read the value of other.__l, even if it isn't the active member. This appears to be legal and also follows the same rationale used when reading / writing memory in __rep.__r.

C++03 / C++11 and on support:

The C++11 standard says "If any non-static data member of a union has a non-trivial default constructor (12.1), copy constructor (12.8), move constructor (12.8), copy assignment operator (12.8), move assignment operator (12.8), or destructor (12.4), the corresponding member function of the union must be user-provided or it will be implicitly deleted (8.4.3) for the union." (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf, 9.5.2).

However, the C++03 standard says "An object of a class with a non-trivial default constructor (12.1), a non-trivial copy constructor (12.8), a non-trivial destructor (12.4), or a non-trivial copy assignment operator (13.5.3, 12.8) cannot be a member of a union". Since the __long contains a fancy pointer which is not trivially constructible, __long itself is not trivially constructible and therefore __rep cannot include it as a member in C++03. Therefore, fancy pointers can only be supported for C++11 and later.

[bemeryesr]

Use regular instead of curly braces in member initializer list

[bemeryesr]

Change noexcept specifier to _NOEXCEPT macro to support c++03

[bemeryesr]

Fix clang tidy formatting issues

[bemeryesr]

Support fancy pointers only for C++11 and later

The C++03 standard says "An object of a class with a non-trivial default constructor,
a non-trivial copy constructor or a non-trivial copy assignment operator cannot be a
member of a union. Therefore, we cannot support fancy pointers in C++03.

[bemeryesr]

Include string before checking preprocessor macro definition

[bemeryesr]

Apply clang formatting

[bemeryesr]

Incorporate changes from master

[bemeryesr]

Move test mains outside ifdef check

[bemeryesr]

Add expected-no-diagnostics to empty fail test

[bemeryesr]

Add templated copy constructor

[bemeryesr]

Add pointer and iterator traits to test classes

[bemeryesr]

Use remove_cv::type for c++11 compatibility.

[bemeryesr]

Use add_lvalue_reference::type for c++11 compatibility.

[philnik]

Thanks for working on this! I think in general you take the right approach, but currently the implementation is broken. For example

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

template <class T>
class alignas(std::max(alignof(T), alignof(std::ptrdiff_t))) OffsetPtr {
  std::ptrdiff_t offset;

public:
  using value_type        = T;
  using iterator_category = std::random_access_iterator_tag;
  using difference_type   = std::ptrdiff_t;
  using pointer           = OffsetPtr;
  using reference         = T&;

  OffsetPtr() = default;
  OffsetPtr(const OffsetPtr& other) : offset(other.operator->() - reinterpret_cast<T*>(this)) {}
  operator OffsetPtr<const T>() const { return OffsetPtr<const T>{reinterpret_cast<const T*>(this) + offset}; }

  OffsetPtr& operator=(const OffsetPtr& other) {
    T* ptr = other.operator->();
    offset = ptr - reinterpret_cast<T*>(this);
    return *this;
  }

  explicit OffsetPtr(T* ptr) : offset(ptr - reinterpret_cast<T*>(this)) {}
  T* operator->() const { return reinterpret_cast<T*>(const_cast<OffsetPtr*>(this)) + offset; }
  T& operator[](size_t i) { return operator->()[i]; }

  static OffsetPtr pointer_to(T& e) { return OffsetPtr(&e); }

  friend OffsetPtr operator+(const OffsetPtr& lhs, size_t rhs) { return OffsetPtr{lhs.operator->() + rhs}; }
};

static_assert(sizeof(OffsetPtr<int>) == 8);

template <class T>
class OffsetPtrAllocator {
public:
  using value_type = T;
  using pointer    = OffsetPtr<T>;

  pointer allocate(size_t n) { return pointer(std::allocator<T>{}.allocate(n)); }

  void deallocate(pointer ptr, size_t n) { std::allocator<T>{}.deallocate(ptr.operator->(), n); }
};

int main() {
  using string = std::basic_string<char, std::char_traits<char>, OffsetPtrAllocator<char>>;
  string str3 = "almost long string";
  string str4 = std::move(str3);
  assert(str4 == "almost long string");
}

was rejected before this patch, but now results in wrong results. The assert(str4 == "almost long string") fails with your current patch. While the OffsetPtr has undefined behaviour, it works and is used in a slightly different style as boost::interprocess::offset_ptr in practice. You could also use a pointer and add additional state to avoid the UB. Also, we have rejected these kinds of pointers until now, so we can still define the ABI. We should at least consider whether we want to use the alternate layout for fancy pointers. @ldionne WDYT?

libcxx/include/string

687

AFAICT pointers don't have to have trivial destructors.

libcxx/test/libcxx/strings/basic.string/allocator_with_fancy_pointer.pass.cpp

1 ↗

(On Diff #456628)

Instead of having a single test, you should add the allocator to test_allocator.h and add an instantiation to all the string tests to have proper coverage.

libcxx/test/libcxx/strings/basic.string/allocator_with_fancy_pointer_non_trivial_destructor.fail.cpp

1 ↗

(On Diff #456628)

This should be a .verify.cpp, not a .fail.cpp.

15 ↗

(On Diff #456628)

You can just add // UNSUPPORTED: c++03 instead.

[bemeryesr]

Update string and unit tests

[bemeryesr]

Thanks for the feedback! Regarding your OffsetPtr example:

1. My initial code was broken as it was calling the copy assignment operator of __long even if __rep was a short string. For an offset pointer, the copy assignment operator recalculates the offset to the pointed-to address and so the copied value will be different to the original. Hence, it failed for short strings. So now I perform the copy depending on whether it's a short or a long string.
2. As I think you alluded to, it seems that some of the pointer arithmetic is optimized-away by the compiler, leading to incorrect behaviour. In boost::interprocess::offset_ptr they mentioned this: "Note: using the address of a local variable to point to another address is not standard conforming and this can be optimized-away by the compiler. Non-inlining is a method to remain illegal but correct." To deal with this, we used a couple of tricks that prevent the functions from being inlined and the test passes. Would it make sense to add this code as a unit test as is? Or perhaps we should find a better way to deal with the UB? This is the code that works for me:

// main.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 <string>

#include "OffsetPtr.h"

int main()
{
    using string = std::basic_string<char, std::char_traits<char>, OffsetPtrAllocator<char>>;
    {
        string str3 = "almost long string";
        string str4 = std::move(str3);
        assert(str4 == "almost long string");
    }
}

// OffsetPtr.h
#ifndef OFFSETPTR_H
#define OFFSETPTR_H

#include <cassert>
#include <cstdint>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <utility>

namespace detail
{
using local_difference_type = std::ptrdiff_t;

local_difference_type SubtractPointersBytesImpl(const volatile void* ptr1, const volatile void* ptr2);

// Alias for checking if template types are of the same type after stripping const/volatile qualifiers.
template <typename T1, typename T2>
using cv_stripped_types_equal =
    typename std::is_same<typename std::remove_cv<T1>::type, typename std::remove_cv<T2>::type>;

template <typename T1, typename T2, typename = std::enable_if_t<cv_stripped_types_equal<T1, T2>::value>>
constexpr local_difference_type SubtractPointersBytes(T1* const ptr1, T2* const ptr2)
{
    return SubtractPointersBytesImpl(ptr1, ptr2);
}

template <typename T>
constexpr const T* __attribute__((noinline)) AddOffsetToPointer(const T* const ptr, local_difference_type offset)
{
    return reinterpret_cast<const T*>(reinterpret_cast<const std::uint8_t*>(ptr) + offset);
}

template <typename T>
constexpr const T* __attribute__((noinline)) AddOffsetToPointer(T* const ptr, local_difference_type offset)
{
    return reinterpret_cast<T*>(reinterpret_cast<std::uint8_t*>(ptr) + offset);
}

}  // namespace detail

template <class T>
class alignas(std::max(alignof(T), alignof(std::ptrdiff_t))) OffsetPtr
{
    std::ptrdiff_t offset;

  public:
    using value_type = T;
    using iterator_category = std::random_access_iterator_tag;
    using difference_type = detail::local_difference_type;
    using pointer = OffsetPtr;
    using reference = T&;

    constexpr OffsetPtr() = default;
    constexpr OffsetPtr(const OffsetPtr& other)
        : offset(detail::SubtractPointersBytes(other.operator->(), reinterpret_cast<T*>(this)))
    {
    }

    constexpr operator OffsetPtr<const T>() const
    {
        return OffsetPtr<const T>{detail::AddOffsetToPointer(reinterpret_cast<const T*>(this), offset)};
    }

    constexpr OffsetPtr& operator=(const OffsetPtr& other)
    {
        T* ptr = other.operator->();
        offset = detail::SubtractPointersBytes(ptr, reinterpret_cast<T*>(this));
        return *this;
    }

    constexpr explicit OffsetPtr(T* ptr) : offset(detail::SubtractPointersBytes(ptr, reinterpret_cast<T*>(this))) {}

    constexpr T* operator->() const
    {
        return const_cast<T*>(detail::AddOffsetToPointer(reinterpret_cast<T*>(const_cast<OffsetPtr*>(this)), offset));
    }

    constexpr T& operator[](size_t i) { return operator->()[i]; }

    static OffsetPtr pointer_to(T& e) { return OffsetPtr(&e); }

    friend OffsetPtr operator+(const OffsetPtr& lhs, size_t rhs)
    {
        return OffsetPtr{detail::AddOffsetToPointer(lhs.operator->(), rhs)};
    }
};

static_assert(sizeof(OffsetPtr<int>) == 8, "");

template <class T>
class OffsetPtrAllocator
{
  public:
    using value_type = T;
    using pointer = OffsetPtr<T>;

    pointer allocate(size_t n) { return pointer(std::allocator<T>{}.allocate(n)); }

    void deallocate(pointer ptr, size_t n) { std::allocator<T>{}.deallocate(ptr.operator->(), n); }
};

#endif  // OFFSETPTR_H

// OffsetPtr.cpp
#include "OffsetPtr.h"

namespace detail
{

local_difference_type SubtractPointersBytesImpl(const volatile void* const ptr1, const volatile void* const ptr2)
{
    return local_difference_type(reinterpret_cast<local_difference_type>(ptr1) -
                                 reinterpret_cast<local_difference_type>(ptr2));
}

}  // namespace detail

libcxx/include/string

687

Yeah, you're right. As of C++20, we can use constexpr destructors. Before C++20 they must be trivial in order for basic_string to be constexpr.

[bemeryesr]

Update failing unit tests

[bemeryesr]

Manually apply formatting patch from CI

[bemeryesr]

Manually apply formatting patch from CI

[bemeryesr]

Update formatting

[bemeryesr]

Fix failing C++03 tests

[bemeryesr]

Fix broken unit tests

[bemeryesr]

Fix unit tests

[bemeryesr]

Fix unit tests

[bemeryesr]

Fix debug unit tests

[bemeryesr]

Hi @philnik. When you get a chance, could you please have a look at my PR? I made a few changes as mentioned in my comment a while ago. I also updated all the unit tests to also use a fancy pointer allocator. Thanks!

In D132149#3799799, @bemeryesr wrote:

Thanks for the feedback! Regarding your OffsetPtr example:

1. My initial code was broken as it was calling the copy assignment operator of __long even if __rep was a short string. For an offset pointer, the copy assignment operator recalculates the offset to the pointed-to address and so the copied value will be different to the original. Hence, it failed for short strings. So now I perform the copy depending on whether it's a short or a long string.
2. As I think you alluded to, it seems that some of the pointer arithmetic is optimized-away by the compiler, leading to incorrect behaviour. In boost::interprocess::offset_ptr they mentioned this: "Note: using the address of a local variable to point to another address is not standard conforming and this can be optimized-away by the compiler. Non-inlining is a method to remain illegal but correct." To deal with this, we used a couple of tricks that prevent the functions from being inlined and the test passes. Would it make sense to add this code as a unit test as is? Or perhaps we should find a better way to deal with the UB? This is the code that works for me:

// main.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 <string>

#include "OffsetPtr.h"

int main()
{
    using string = std::basic_string<char, std::char_traits<char>, OffsetPtrAllocator<char>>;
    {
        string str3 = "almost long string";
        string str4 = std::move(str3);
        assert(str4 == "almost long string");
    }
}

// OffsetPtr.h
#ifndef OFFSETPTR_H
#define OFFSETPTR_H

#include <cassert>
#include <cstdint>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <utility>

namespace detail
{
using local_difference_type = std::ptrdiff_t;

local_difference_type SubtractPointersBytesImpl(const volatile void* ptr1, const volatile void* ptr2);

// Alias for checking if template types are of the same type after stripping const/volatile qualifiers.
template <typename T1, typename T2>
using cv_stripped_types_equal =
    typename std::is_same<typename std::remove_cv<T1>::type, typename std::remove_cv<T2>::type>;

template <typename T1, typename T2, typename = std::enable_if_t<cv_stripped_types_equal<T1, T2>::value>>
constexpr local_difference_type SubtractPointersBytes(T1* const ptr1, T2* const ptr2)
{
    return SubtractPointersBytesImpl(ptr1, ptr2);
}

template <typename T>
constexpr const T* __attribute__((noinline)) AddOffsetToPointer(const T* const ptr, local_difference_type offset)
{
    return reinterpret_cast<const T*>(reinterpret_cast<const std::uint8_t*>(ptr) + offset);
}

template <typename T>
constexpr const T* __attribute__((noinline)) AddOffsetToPointer(T* const ptr, local_difference_type offset)
{
    return reinterpret_cast<T*>(reinterpret_cast<std::uint8_t*>(ptr) + offset);
}

}  // namespace detail

template <class T>
class alignas(std::max(alignof(T), alignof(std::ptrdiff_t))) OffsetPtr
{
    std::ptrdiff_t offset;

  public:
    using value_type = T;
    using iterator_category = std::random_access_iterator_tag;
    using difference_type = detail::local_difference_type;
    using pointer = OffsetPtr;
    using reference = T&;

    constexpr OffsetPtr() = default;
    constexpr OffsetPtr(const OffsetPtr& other)
        : offset(detail::SubtractPointersBytes(other.operator->(), reinterpret_cast<T*>(this)))
    {
    }

    constexpr operator OffsetPtr<const T>() const
    {
        return OffsetPtr<const T>{detail::AddOffsetToPointer(reinterpret_cast<const T*>(this), offset)};
    }

    constexpr OffsetPtr& operator=(const OffsetPtr& other)
    {
        T* ptr = other.operator->();
        offset = detail::SubtractPointersBytes(ptr, reinterpret_cast<T*>(this));
        return *this;
    }

    constexpr explicit OffsetPtr(T* ptr) : offset(detail::SubtractPointersBytes(ptr, reinterpret_cast<T*>(this))) {}

    constexpr T* operator->() const
    {
        return const_cast<T*>(detail::AddOffsetToPointer(reinterpret_cast<T*>(const_cast<OffsetPtr*>(this)), offset));
    }

    constexpr T& operator[](size_t i) { return operator->()[i]; }

    static OffsetPtr pointer_to(T& e) { return OffsetPtr(&e); }

    friend OffsetPtr operator+(const OffsetPtr& lhs, size_t rhs)
    {
        return OffsetPtr{detail::AddOffsetToPointer(lhs.operator->(), rhs)};
    }
};

static_assert(sizeof(OffsetPtr<int>) == 8, "");

template <class T>
class OffsetPtrAllocator
{
  public:
    using value_type = T;
    using pointer = OffsetPtr<T>;

    pointer allocate(size_t n) { return pointer(std::allocator<T>{}.allocate(n)); }

    void deallocate(pointer ptr, size_t n) { std::allocator<T>{}.deallocate(ptr.operator->(), n); }
};

#endif  // OFFSETPTR_H

// OffsetPtr.cpp
#include "OffsetPtr.h"

namespace detail
{

local_difference_type SubtractPointersBytesImpl(const volatile void* const ptr1, const volatile void* const ptr2)
{
    return local_difference_type(reinterpret_cast<local_difference_type>(ptr1) -
                                 reinterpret_cast<local_difference_type>(ptr2));
}

}  // namespace detail

[philnik]

libcxx/include/string

687

basic_string isn't constexpr before C++20. Either way, we have to support non-constexpr pointers. AFAIK nothing in the standard requires the pointer to work during constant evaluation.

778

Why is this special-casing needed? AFAICT the code below is valid in C++03.

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

22

Please move these test refactorings into it's own PR. This diff is really large.

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

94

It doesn't seem like this change adds any coverage. The fancy_pointer_allocator doesn't change anything w.r.t. max_size, does it?

136

Could you enable the constexpr test as a drive-by?

[ldionne]

I think this patch has a lot of value. @bemeryesr are you blocked on anything wrt this patch?

[bemeryesr]

• Remove static assert for trivial destructibility of pointer.
• Make comments a bit clearer.
• Remove unit test changes (will be added in separate PR).

[bemeryesr]

In D132149#4009312, @ldionne wrote:

I think this patch has a lot of value. @bemeryesr are you blocked on anything wrt this patch?

Sorry about the delay, I've been sick. I just pushed a new patch addressing the comments from @philnik.

[bemeryesr]

libcxx/include/string

687

Done (Removed static assert) .

778

This is needed because the C++03 standard says "An object of a class with a non-trivial default constructor (12.1), a non-trivial copy constructor (12.8), a non-trivial destructor (12.4), or a non-trivial copy assignment operator (13.5.3, 12.8) cannot be a member of a union". Since long contains a fancy pointer which is not trivially constructible, long itself is not trivially constructible and therefore __rep cannot include it as a member in C++03.

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

22

Done, I will add a link to the PR when I upload it later today.

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

94

Yep, you're right. I will remove it in the separate PR.

136

Actually, it's since been enabled (https://reviews.llvm.org/D128578#change-59T6waF87eYp).

[bemeryesr]

Update clang formatting

[philnik]

I think you misunderstood what I was asking for regarding the tests. I wanted you to move the refactoring into it's own patch, so that the test changes here would be just a single line per test.

libcxx/include/string

778

That doesn't change anything between the two versions though. C++03 doesn't work with fancy pointers either way. Actually, why do we need a default constructor in the union at all?

[ldionne]

In D132149#4010106, @bemeryesr wrote:

In D132149#4009312, @ldionne wrote:

I think this patch has a lot of value. @bemeryesr are you blocked on anything wrt this patch?

Sorry about the delay, I've been sick. I just pushed a new patch addressing the comments from @philnik.

Oh, no worries, I hope you're feeling better now. I just wanted to make sure this wasn't stalled due to a miscommunication.

[bemeryesr]

• Make this PR a child of D140550 and D140612 which refactor and apply clang formatting to the string unit tests. This PR now simply adds the fancy pointer allocator to the tests.
• Remove special casing for C++03 for __ulx struct as it doesn't require a default constructor.

[bemeryesr]

In D132149#4010578, @philnik wrote:

I think you misunderstood what I was asking for regarding the tests. I wanted you to move the refactoring into it's own patch, so that the test changes here would be just a single line per test.

Ok, got it now, sorry for the misunderstanding. I created 2 additional PRs. The first refactors the unit tests (D140550) and the second applies clang formatting to all the string tests (D140612).

libcxx/include/string

778

Ah yeah, you're right. It seems that __ulx is only used by the sizeof operator below so we don't need a default constructor. I've removed the special casing.

[bemeryesr]

Apply clang formatting

[ldionne]

@bemeryesr Do you still have interest in working on this? I landed the clang-format refactoring for the std::string tests and I can take over D140550 like next week. If you still want to land this patch, please ping me on Discord and we'll coordinate.

[ldionne]

Abandoning in favor of https://github.com/llvm/llvm-project/pull/71182

libcxx/include/string

public:
 
     static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array");
     static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout");
     static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial");
     static_assert(( is_same<_CharT, typename traits_type::char_type>::value),
                   "traits_type::char_type must be the same type as CharT");
     static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
+#if _LIBCPP_STD_VER < 20
+    static_assert((is_trivially_destructible<pointer>::value), "pointer type must have a trivial destructor.");
+#endif
 
     typedef __wrap_iter<pointer>                         iterator;
     typedef __wrap_iter<const_pointer>                   const_iterator;
     typedef std::reverse_iterator<iterator>              reverse_iterator;
     typedef std::reverse_iterator<const_iterator>        const_reverse_iterator;
 
 private:
     static_assert(CHAR_BIT == 8, "This implementation assumes that one byte contains 8 bits");
struct __short
         char __padding_[sizeof(value_type) - 1];
         value_type __data_[__min_cap];
     };
 
 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     static_assert(sizeof(__short) == (sizeof(value_type) * (__min_cap + 1)), "__short has an unexpected size.");
 
+#ifdef _LIBCPP_CXX03_LANG
     union __ulx{__long __lx; __short __lxx;};
+#else
+    // Since C++03, unions can contain members with non-trivial special member functions. The corresponding special
+    // member functions of the union will be deleted and therefore must be explicitly defined. To support fancy pointers
+    // with non-trivial constructors in __long, we must explicitly define a constructor in __ulx, as the default
+    // constructor will be deleted.
+    union __ulx {
+      _LIBCPP_CONSTEXPR_SINCE_CXX20 __ulx() _NOEXCEPT : __lx{} {}
+
+      __long __lx;
+      __short __lxx;
+    };
+#endif // _LIBCPP_CXX03_LANG
 
     enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
 
     struct __raw
     {
         size_type __words[__n_words];
     };
 
+#ifdef _LIBCPP_CXX03_LANG
     struct __rep
     {
         union
         {
             __long  __l;
             __short __s;
             __raw   __r;
         };
     };
+#else
+    // Since C++03, unions can contain members with non-trivial special member functions. The corresponding special
+    // member functions of the union will be deleted and therefore must be explicitly defined. To support fancy pointers
+    // with non-trivial special member functions in __long, we must explicitly define a constructor, copy constructor
+    // and copy assignment operator in __rep. Since C++20, unions can also contain members with non-trivial destructors.
+    struct __rep {
+      _LIBCPP_CONSTEXPR_SINCE_CXX20 __rep() _NOEXCEPT : __l{} {}
+      _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__rep() _NOEXCEPT {}
+
+      _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_rep_long(const __rep& __str_rep) const _NOEXCEPT {
+        if (__libcpp_is_constant_evaluated())
+          return true;
+        return __str_rep.__l.__is_long_;
+      }
+
+      _LIBCPP_CONSTEXPR_SINCE_CXX20 __rep(const __rep& __other) _NOEXCEPT : __l{} {
+        // For certain fancy pointers such as offset pointers, the value of __l.__data_ will be different for 2 pointers
+        // pointing to the same object (because the offset is calculated with respect to the pointer itself). Therefore,
+        // the copy assignment operator of the underlying pointer needs to be explicitly called. For a short string, the
+        // memory should be directly copied.
+        if (__is_rep_long(__other)) {
+          __l.__is_long_ = __other.__l.__is_long_;
+          __l.__cap_     = __other.__l.__cap_;
+          __l.__size_    = __other.__l.__size_;
+          __l.__data_    = __other.__l.__data_;
+        } else {
+          for (unsigned __i = 0; __i < __n_words; ++__i)
+            __r.__words[__i] = __other.__r.__words[__i];
+        }
+      }
+
+      _LIBCPP_CONSTEXPR_SINCE_CXX20 __rep& operator=(const __rep& __other) _NOEXCEPT {
+        if (this != &__other) {
+          if (__is_rep_long(__other)) {
+            __l.__is_long_ = __other.__l.__is_long_;
+            __l.__cap_     = __other.__l.__cap_;
+            __l.__size_    = __other.__l.__size_;
+            __l.__data_    = __other.__l.__data_;
+          } else {
+            for (unsigned __i = 0; __i < __n_words; ++__i)
+              __r.__words[__i] = __other.__r.__words[__i];
+          }
+        }
+        return *this;
+      }
+
+      union {
+        __long __l;
+        __short __s;
+        __raw __r;
+      };
+    };
+#endif // _LIBCPP_CXX03_LANG
 
     __compressed_pair<__rep, allocator_type> __r_;
 
     // Construct a string with the given allocator and enough storage to hold `__size` characters, but
     // don't initialize the characters. The contents of the string, including the null terminator, must be
     // initialized separately.
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     explicit basic_string(__uninitialized_size_tag, size_type __size, const allocator_type& __a)

libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp

public:
   friend bool operator==(small_iter_allocator, small_iter_allocator) { return true; }
   friend bool operator!=(small_iter_allocator, small_iter_allocator) { return false; }
 };
 
 template <class CharT>
 using min_string = std::basic_string<CharT, std::char_traits<CharT>, min_allocator<CharT>>;
 
 template <class CharT>
+using fancy_string = std::basic_string<CharT, std::char_traits<CharT>, fancy_pointer_allocator<CharT>>;
+
+template <class CharT>
 using test_string = std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
 
 template <class CharT>
 using small_string = std::basic_string<CharT, std::char_traits<CharT>, small_iter_allocator<CharT>>;
 
 #if __SIZE_WIDTH__ == 64
 
 static_assert(alignof(std::string) == 8, "");
 static_assert(alignof(min_string<char>) == 8, "");
+static_assert(alignof(fancy_string<char>) == 8, "");
 static_assert(alignof(test_string<char>) == 8, "");
 static_assert(alignof(small_string<char>) == 2, "");
 
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
 #    if __WCHAR_WIDTH__ == 32
 static_assert(alignof(std::wstring) == 8, "");
 static_assert(alignof(min_string<wchar_t>) == 8, "");
+static_assert(alignof(fancy_string<wchar_t>) == 8, "");
 static_assert(alignof(test_string<wchar_t>) == 8, "");
 static_assert(alignof(small_string<wchar_t>) == 4, "");
 #    elif __WCHAR_WIDTH__ == 16
 static_assert(alignof(std::wstring) == 8, "");
 static_assert(alignof(min_string<wchar_t>) == 8, "");
+static_assert(alignof(fancy_string<wchar_t>) == 8, "");
 static_assert(alignof(test_string<wchar_t>) == 8, "");
 static_assert(alignof(small_string<wchar_t>) == 2, "");
 #    else
 #      error "Unexpected wchar_t width"
 #    endif
 #  endif
 
 #  ifndef TEST_HAS_NO_CHAR8_T
 static_assert(alignof(std::u8string) == 8, "");
 static_assert(alignof(min_string<char8_t>) == 8, "");
+static_assert(alignof(fancy_string<char8_t>) == 8, "");
 static_assert(alignof(test_string<char8_t>) == 8, "");
 static_assert(alignof(small_string<char8_t>) == 2, "");
 #  endif
 
 #  ifndef TEST_HAS_NO_UNICODE_CHARS
 static_assert(alignof(std::u16string) == 8, "");
 static_assert(alignof(std::u32string) == 8, "");
 static_assert(alignof(min_string<char16_t>) == 8, "");
 static_assert(alignof(min_string<char32_t>) == 8, "");
+static_assert(alignof(fancy_string<char32_t>) == 8, "");
+static_assert(alignof(fancy_string<char32_t>) == 8, "");
 static_assert(alignof(test_string<char16_t>) == 8, "");
 static_assert(alignof(test_string<char32_t>) == 8, "");
 static_assert(alignof(small_string<char16_t>) == 2, "");
 static_assert(alignof(small_string<char32_t>) == 4, "");
 #  endif
 
 #elif __SIZE_WIDTH__ == 32
 
 static_assert(alignof(std::string) == 4, "");
 static_assert(alignof(min_string<char>) == 4, "");
+static_assert(alignof(fancy_string<char>) == 4, "");
 static_assert(alignof(test_string<char>) == 4, "");
 static_assert(alignof(small_string<char>) == 2, "");
 
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
 #    if __WCHAR_WIDTH__ == 32
 static_assert(alignof(std::wstring) == 4, "");
 static_assert(alignof(min_string<wchar_t>) == 4, "");
+static_assert(alignof(fancy_string<wchar_t>) == 4, "");
 static_assert(alignof(test_string<wchar_t>) == 4, "");
 static_assert(alignof(small_string<wchar_t>) == 4, "");
 #    elif __WCHAR_WIDTH__ == 16
 static_assert(alignof(std::wstring) == 4, "");
 static_assert(alignof(min_string<wchar_t>) == 4, "");
+static_assert(alignof(fancy_string<wchar_t>) == 4, "");
 static_assert(alignof(test_string<wchar_t>) == 4, "");
 static_assert(alignof(small_string<wchar_t>) == 2, "");
 #    else
 #      error "Unexpected wchar_t width"
 #    endif
 #  endif
 
 #  ifndef TEST_HAS_NO_CHAR8_T
 static_assert(alignof(std::u8string) == 4, "");
 static_assert(alignof(min_string<char8_t>) == 4, "");
+static_assert(alignof(fancy_string<char8_t>) == 4, "");
 static_assert(alignof(test_string<char8_t>) == 4, "");
 static_assert(alignof(small_string<char8_t>) == 2, "");
 #  endif
 
 #  ifndef TEST_HAS_NO_UNICODE_CHARS
 static_assert(alignof(std::u16string) == 4, "");
 static_assert(alignof(std::u32string) == 4, "");
 static_assert(alignof(min_string<char16_t>) == 4, "");
 static_assert(alignof(min_string<char32_t>) == 4, "");
+static_assert(alignof(fancy_string<char16_t>) == 4, "");
+static_assert(alignof(fancy_string<char32_t>) == 4, "");
 static_assert(alignof(test_string<char16_t>) == 4, "");
 static_assert(alignof(test_string<char32_t>) == 4, "");
 static_assert(alignof(small_string<char32_t>) == 4, "");
 #  endif
 
 #else
 #  error "size_t has an unexpected size"
 #endif

libcxx/test/libcxx/strings/basic.string/allocator_with_fancy_pointer_non_trivial_destructor.verify.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>
+
+// Test that basic_string requires its allocator to use a pointer with a trivial destructor.
+#include "test_macros.h"
+
+#include <string>
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+
+template <class T>
+class NonTriviallyDestructiblePointer {
+public:
+  // For the std::pointer_traits interface.
+  using pointer         = T*;
+  using element_type    = T;
+  using difference_type = std::ptrdiff_t;
+
+  template <class U>
+  using rebind = NonTriviallyDestructiblePointer<U>;
+
+  // For the std::iterator_traits interface.
+  using value_type        = typename std::remove_cv<T>::type;
+  using reference         = typename std::add_lvalue_reference<T>::type;
+  using iterator_category = std::random_access_iterator_tag;
+
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 NonTriviallyDestructiblePointer() {} // non-trivial constructor
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 NonTriviallyDestructiblePointer(T* p) : ptr(p) {}
+
+  template <typename T2>
+  NonTriviallyDestructiblePointer(const NonTriviallyDestructiblePointer<T2>& other) noexcept : ptr(other.get()) {}
+
+  operator T*() const { return ptr; }
+  NonTriviallyDestructiblePointer(NonTriviallyDestructiblePointer&&)                 = default;
+  NonTriviallyDestructiblePointer(const NonTriviallyDestructiblePointer&)            = default;
+  NonTriviallyDestructiblePointer& operator=(NonTriviallyDestructiblePointer&&)      = default;
+  NonTriviallyDestructiblePointer& operator=(const NonTriviallyDestructiblePointer&) = default;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 ~NonTriviallyDestructiblePointer() {} // non-trivial destructor
+  T& operator*() const { return *ptr; }
+  T* operator->() const { return ptr; }
+  operator bool() const { return ptr; }
+  T* get() const { return ptr; }
+
+  static NonTriviallyDestructiblePointer pointer_to(reference ref) noexcept {
+    return NonTriviallyDestructiblePointer(&ref);
+  }
+
+private:
+  T* ptr;
+};
+
+template <class T>
+class allocator : public std::allocator<T> {
+  using base = std::allocator<T>;
+
+public:
+  using pointer = NonTriviallyDestructiblePointer<T>;
+  pointer allocate(size_t n) { return base::allocate(n); }
+  void deallocate(pointer p, size_t n) { return base::deallocate(p, n); }
+};
+
+int main() {
+#if TEST_STD_VER >= 20
+  std::basic_string<char, std::char_traits<char>, allocator<char> > s; // expected-no-diagnostics
+#else
+  std::basic_string<char, std::char_traits<char>, allocator<char> >
+      s; // expected-error-re@* {{{{.*}}pointer type must have a trivial destructor.}}
+#endif
+}

libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp

public:
   friend bool operator==(small_iter_allocator, small_iter_allocator) { return true; }
   friend bool operator!=(small_iter_allocator, small_iter_allocator) { return false; }
 };
 
 template <class CharT>
 using min_string = std::basic_string<CharT, std::char_traits<CharT>, min_allocator<CharT> >;
 
 template <class CharT>
+using fancy_string = std::basic_string<CharT, std::char_traits<CharT>, fancy_pointer_allocator<CharT> >;
+
+template <class CharT>
 using test_string = std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT> >;
 
 template <class CharT>
 using small_string = std::basic_string<CharT, std::char_traits<CharT>, small_iter_allocator<CharT> >;
 
 #if __SIZE_WIDTH__ == 64
 
 static_assert(sizeof(std::string) == 24, "");
 static_assert(sizeof(min_string<char>) == 24, "");
+#  if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<char>) == 24, "");
+#  endif
 static_assert(sizeof(test_string<char>) == 32, "");
 static_assert(sizeof(small_string<char>) == 6, "");
 
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
 #    if __WCHAR_WIDTH__ == 32
 static_assert(sizeof(std::wstring) == 24, "");
 static_assert(sizeof(min_string<wchar_t>) == 24, "");
+#      if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<wchar_t>) == 24, "");
+#      endif
 static_assert(sizeof(test_string<wchar_t>) == 32, "");
 static_assert(sizeof(small_string<wchar_t>) == 12, "");
 #    elif __WCHAR_WIDTH__ == 16
 static_assert(sizeof(std::wstring) == 24, "");
 static_assert(sizeof(min_string<wchar_t>) == 24, "");
+#      if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<wchar_t>) == 24, "");
+#      endif
 static_assert(sizeof(test_string<wchar_t>) == 32, "");
 static_assert(sizeof(small_string<wchar_t>) == 6, "");
 #    else
 #      error "Unexpected wchar_t width"
 #    endif
 #  endif
 
 #  ifndef TEST_HAS_NO_CHAR8_T
 static_assert(sizeof(std::u8string) == 24, "");
 static_assert(sizeof(min_string<char8_t>) == 24, "");
+#    if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<char8_t>) == 24, "");
+#    endif
 static_assert(sizeof(test_string<char8_t>) == 32, "");
 static_assert(sizeof(small_string<char8_t>) == 6, "");
 #  endif
 
 #  ifndef TEST_HAS_NO_UNICODE_CHARS
 static_assert(sizeof(std::u16string) == 24, "");
 static_assert(sizeof(std::u32string) == 24, "");
 static_assert(sizeof(min_string<char16_t>) == 24, "");
 static_assert(sizeof(min_string<char32_t>) == 24, "");
+#    if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<char16_t>) == 24, "");
+static_assert(sizeof(fancy_string<char32_t>) == 24, "");
+#    endif
 static_assert(sizeof(test_string<char16_t>) == 32, "");
 static_assert(sizeof(test_string<char32_t>) == 32, "");
 static_assert(sizeof(small_string<char16_t>) == 6, "");
 static_assert(sizeof(small_string<char32_t>) == 12, "");
 #  endif
 
 #elif __SIZE_WIDTH__ == 32
 
 static_assert(sizeof(std::string) == 12, "");
 static_assert(sizeof(min_string<char>) == 12, "");
+#  if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<char>) == 12, "");
+#  endif
 static_assert(sizeof(test_string<char>) == 24, "");
 static_assert(sizeof(small_string<char>) == 6, "");
 
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
 #    if __WCHAR_WIDTH__ == 32
 static_assert(sizeof(std::wstring) == 12, "");
 static_assert(sizeof(min_string<wchar_t>) == 12, "");
+#      if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<wchar_t>) == 12, "");
+#      endif
 static_assert(sizeof(test_string<wchar_t>) == 24, "");
 static_assert(sizeof(small_string<wchar_t>) == 12, "");
 #    elif __WCHAR_WIDTH__ == 16
 static_assert(sizeof(std::wstring) == 12, "");
 static_assert(sizeof(min_string<wchar_t>) == 12, "");
+#      if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<wchar_t>) == 12, "");
+#      endif
 static_assert(sizeof(test_string<wchar_t>) == 24, "");
 static_assert(sizeof(small_string<wchar_t>) == 6, "");
 #    else
 #      error "Unexpected wchar_t width"
 #    endif
 #  endif
 
 #  ifndef TEST_HAS_NO_CHAR8_T
 static_assert(sizeof(std::u8string) == 12, "");
 static_assert(sizeof(min_string<char8_t>) == 12, "");
+#    if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<char8_t>) == 12, "");
+#    endif
 static_assert(sizeof(test_string<char8_t>) == 24, "");
 static_assert(sizeof(small_string<char>) == 6, "");
 #  endif
 
 #  ifndef TEST_HAS_NO_UNICODE_CHARS
 static_assert(sizeof(std::u16string) == 12, "");
 static_assert(sizeof(std::u32string) == 12, "");
 static_assert(sizeof(min_string<char16_t>) == 12, "");
 static_assert(sizeof(min_string<char32_t>) == 12, "");
+#    if TEST_STD_VER >= 11
+static_assert(sizeof(fancy_string<char16_t>) == 12, "");
+static_assert(sizeof(fancy_string<char32_t>) == 12, "");
+#    endif
 static_assert(sizeof(test_string<char16_t>) == 24, "");
 static_assert(sizeof(test_string<char32_t>) == 24, "");
 static_assert(sizeof(small_string<char16_t>) == 6, "");
 static_assert(sizeof(small_string<char32_t>) == 12, "");
 #  endif
 
 #else
 #  error "size_t has an unexpected size"
 #endif

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

 // UNSUPPORTED: c++03
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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() {
 
-    return 0;
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
+
 }

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

 // UNSUPPORTED: c++03
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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() {
 
-    return 0;
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
+
 }

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

 // UNSUPPORTED: c++03
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}}
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 void test() {
     // Test that a call to reserve() does shrink the string.
     {
         S s(1000, 'a');
         typename S::size_type old_cap = s.capacity();
         s.resize(20);
void test() {
     }
 }
 
 int main(int, char**) {
     test<std::string>();
 
 #if TEST_STD_VER >= 11
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+    test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
     return 0;
 }

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

 // This test ensures that the correct max_size() is returned depending on the platform.
 
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <string>
 
 #include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
 
 // alignment of the string heap buffer is hardcoded to 16
 static const size_t alignment = 16;
 
+template <template <class> class Alloc>
 void full_size() {
-  std::string str;
+  std::basic_string<char, std::char_traits<char>, Alloc<char> > str;
   assert(str.max_size() == std::numeric_limits<size_t>::max() - alignment);
 
 #ifndef TEST_HAS_NO_CHAR8_T
-  std::u8string u8str;
+  std::basic_string<char8_t, std::char_traits<char8_t>, Alloc<char8_t> > u8str;
   assert(u8str.max_size() == std::numeric_limits<size_t>::max() - alignment);
 #endif
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::wstring wstr;
+  std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> > wstr;
   assert(wstr.max_size() == std::numeric_limits<size_t>::max() / sizeof(wchar_t) - alignment);
 #endif
 
-  std::u16string u16str;
-  std::u32string u32str;
+  std::basic_string<char16_t, std::char_traits<char16_t>, Alloc<char16_t> > u16str;
+  std::basic_string<char32_t, std::char_traits<char32_t>, Alloc<char32_t> > u32str;
   assert(u16str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
   assert(u32str.max_size() == std::numeric_limits<size_t>::max() / 4 - alignment);
 }
 
+template <template <class> class Alloc>
 void half_size() {
-  std::string str;
+  std::basic_string<char, std::char_traits<char>, Alloc<char> > str;
   assert(str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
 
 #ifndef TEST_HAS_NO_CHAR8_T
-  std::u8string u8str;
+  std::basic_string<char8_t, std::char_traits<char8_t>, Alloc<char8_t> > u8str;
   assert(u8str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
 #endif
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::wstring wstr;
+  std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> > wstr;
   assert(wstr.max_size() == std::numeric_limits<size_t>::max() / std::max<size_t>(2ul, sizeof(wchar_t)) - alignment);
 #endif
 
-  std::u16string u16str;
-  std::u32string u32str;
+  std::basic_string<char16_t, std::char_traits<char16_t>, Alloc<char16_t> > u16str;
+  std::basic_string<char32_t, std::char_traits<char32_t>, Alloc<char32_t> > u32str;
   assert(u16str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
   assert(u32str.max_size() == std::numeric_limits<size_t>::max() / 4 - alignment);
 }
 
 bool test() {
-
 #if _LIBCPP_ABI_VERSION == 1
 
-# if defined(__x86_64__) || defined(__i386__)
-  full_size();
-# elif defined(__APPLE__) && defined(__aarch64__)
-  half_size();
-# elif defined(__arm__) || defined(__aarch64__)
-#   ifdef __BIG_ENDIAN__
-  half_size();
-#   else
-  full_size();
-#   endif
-# elif defined(__powerpc__) || defined(__powerpc64__)
-#   ifdef __BIG_ENDIAN__
-  half_size();
-#   else
-  full_size();
-#   endif
-# elif defined(__sparc64__)
-  half_size();
-# elif defined(_WIN32)
-  full_size();
-# else
-#   error "Your target system seems to be unsupported."
-# endif
+#  if defined(__x86_64__) || defined(__i386__)
+  full_size<std::allocator>();
+#  elif defined(__APPLE__) && defined(__aarch64__)
+  half_size<std::allocator>();
+#  elif defined(__arm__) || defined(__aarch64__)
+#    ifdef __BIG_ENDIAN__
+  half_size<std::allocator>();
+#    else
+  full_size<std::allocator>();
+#    endif
+#  elif defined(__powerpc__) || defined(__powerpc64__)
+#    ifdef __BIG_ENDIAN__
+  half_size<std::allocator>();
+#    else
+  full_size<std::allocator>();
+#    endif
+#  elif defined(__sparc64__)
+  half_size<std::allocator>();
+#  elif defined(_WIN32)
+  full_size<std::allocator>();
+#  else
+#    error "Your target system seems to be unsupported."
+#  endif
 
+#  if TEST_STD_VER >= 11
+
+#    if defined(__x86_64__) || defined(__i386__)
+  full_size<fancy_pointer_allocator>();
+#    elif defined(__APPLE__) && defined(__aarch64__)
+  half_size<fancy_pointer_allocator>();
+#    elif defined(__arm__) || defined(__aarch64__)
+#      ifdef __BIG_ENDIAN__
+  half_size<fancy_pointer_allocator>();
+#      else
+  full_size<fancy_pointer_allocator>();
+#      endif
+#    elif defined(__powerpc__) || defined(__powerpc64__)
+#      ifdef __BIG_ENDIAN__
+  half_size<fancy_pointer_allocator>();
+#      else
+  full_size<fancy_pointer_allocator>();
+#      endif
+#    elif defined(__sparc64__)
+  half_size<fancy_pointer_allocator>();
+#    elif defined(_WIN32)
+  full_size<fancy_pointer_allocator>();
+#    else
+#      error "Your target system seems to be unsupported."
+#    endif
+#  endif
 #else
 
-  half_size();
+  half_size<std::allocator>();
+#  if TEST_STD_VER >= 11
+  half_size<min_allocator>();
+  half_size<fancy_pointer_allocator>();
+#  endif
 
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   // static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.cons/copy_shrunk_long.pass.cpp

test()
   S s2(s1);
   LIBCPP_ASSERT(s2.__invariants());
   assert(s2 == s1);
   assert(s2.capacity() < sizeof(S));
 }
 
 int main(int, char**)
 {
-    {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test<S>();
-    }
+  test<std::string>();
 #if TEST_STD_VER >= 11
-    {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test<S>();
-    }
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char>>>();
 #endif
 
   return 0;
 }

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

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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() {
 
-  {
-    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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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() {
 
-  {
-    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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

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

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

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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() {
 
-  {
-    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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

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

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

 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 // UNSUPPORTED: c++03
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
   return 0;
 }

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

 // REQUIRES: has-unix-headers
 // UNSUPPORTED: c++03
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 #include <string>
 
 #include "check_assertion.h"
+#include "test_allocator.h"
 
-int main(int, char**) {
-    std::string s;
-    TEST_LIBCPP_ASSERT_FAILURE(s.pop_back(), "string::pop_back(): string is already empty");
+template <class S>
+void test() {
+  S s;
+}
+
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
-    return 0;
 }

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

 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_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() {
+  TEST_LIBCPP_ASSERT_FAILURE(
+      l1.erase(i), "string::erase(iterator) called with an iterator not referring to this string");
 
-    return 0;
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
+
 }

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

 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
-int main(int, char**) {
-
-    // With first iterator from another container
-    {
-        {
-            std::string l1("123");
-            std::string l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(
-                l1.erase(l2.cbegin(), l1.cbegin() + 1),
-                "string::erase(iterator,  iterator) called with an iterator not referring to this string");
-        }
-        {
-            typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-            S l1("123");
-            S l2("123");
-            TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), l1.cbegin() + 1),
-                                        "string::erase(iterator,  iterator) called with an iterator not referring to this string");
-        }
-    }
+template <class S>
+void test() {
+    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");
-        }
-    }
 
-    // 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");
-        }
-    }
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l1.cbegin() + 1, l1.cbegin()), "string::erase(first, last) called with invalid range");
 
-    return 0;
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
+
 }

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

 //       actually work if the dylib hasn't been built with debug assertions enabled.
 //       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"
+#include "test_allocator.h"
 
-int main(int, char**) {
-    typedef std::string S;
-    S s;
-    S s2;
-    TEST_LIBCPP_ASSERT_FAILURE(s.insert(s2.begin(), '1'),
-        "string::insert(iterator, character) called with an iterator not referring to this string");
+template <class S>
+void test() {
+  TEST_LIBCPP_ASSERT_FAILURE(
+      s.insert(s2.begin(), '1'),
+}
+
+int main(int, char**) {
+  test<std::string>();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
-    return 0;
 }

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

 //   iterator insert(const_iterator p, InputIterator first, InputIterator last);
 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
+#include "test_allocator.h"
 
-int main(int, char**) {
-    std::string v;
-    std::string v2;
-    char a[] = "123";
-    const int N = sizeof(a)/sizeof(a[0]);
-    TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin() + 10, a, a + N),
-                               "Attempted to add/subtract an iterator outside its valid range");
+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>();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
-    return 0;
 }

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

 // iterator insert(const_iterator p, size_type n, charT c);
 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: !libcpp-has-debug-mode, c++03
 
 #include <string>
 
 #include "check_assertion.h"
+#include "test_allocator.h"
 
-int main(int, char**) {
-    std::string s;
-    std::string s2;
-    TEST_LIBCPP_ASSERT_FAILURE(
-        s.insert(s2.begin(), 1, 'a'),
+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>();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >>();
 
-    return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.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>
 
 // __resize_default_init(size_type)
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
 void write_c_str(char *buf, int size) {
   for (int i=0; i < size; ++i) {
     buf[i] = 'a';
   }
   buf[size] = '\0';
 }
 
-void test_buffer_usage()
-{
+template <class S>
+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(strlen(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>
 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);
   }
 }
 
 int main(int, char**) {
-  test_basic();
-  test_buffer_usage();
-
+  test_basic<std::string>();
+  test_buffer_usage<std::string>();
+#if TEST_STD_VER >= 11
+  test_basic<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+  test_buffer_usage<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+#endif
   return 0;
 }

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

 // const_reference at(size_type pos) const; // constexpr since C++20
 //       reference at(size_type pos); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #include "test_macros.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::size_type pos)
-{
-    const S& cs = s;
-    if (pos < s.size())
-    {
-        assert(s.at(pos) == s[pos]);
-        assert(cs.at(pos) == cs[pos]);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type pos) {
+  if (pos < s.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            TEST_IGNORE_NODISCARD s.at(pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos >= s.size());
-        }
-        try
-        {
-            TEST_IGNORE_NODISCARD cs.at(pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos >= s.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0);
   test(S("123"), 0);
   test(S("123"), 1);
   test(S("123"), 2);
   test(S("123"), 3);
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.access/back.pass.cpp

 // const charT& back() const; // constexpr since C++20
 //       charT& back(); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s.back()), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs.back()), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s.back());
-    LIBCPP_ASSERT_NOEXCEPT(   cs.back());
-    assert(&cs.back() == &cs[cs.size()-1]);
-    assert(&s.back() == &s[cs.size()-1]);
-    s.back() = typename S::value_type('z');
-    assert(s.back() == typename S::value_type('z'));
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  ASSERT_SAME_TYPE(decltype(s.back()), typename S::reference);
+  LIBCPP_ASSERT_NOEXCEPT(s.back());
+  LIBCPP_ASSERT_NOEXCEPT(cs.back());
+  assert(&cs.back() == &cs[cs.size() - 1]);
+  assert(&s.back() == &s[cs.size() - 1]);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("1"));
   test(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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.access/front.pass.cpp

 // const charT& front() const; // constexpr since C++20
 //       charT& front(); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s.front()), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs.front()), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s.front());
-    LIBCPP_ASSERT_NOEXCEPT(   cs.front());
-    assert(&cs.front() == &cs[0]);
-    assert(&s.front() == &s[0]);
-    s.front() = typename S::value_type('z');
-    assert(s.front() == typename S::value_type('z'));
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  ASSERT_SAME_TYPE(decltype(s.front()), typename S::reference);
+  LIBCPP_ASSERT_NOEXCEPT(s.front());
+  LIBCPP_ASSERT_NOEXCEPT(cs.front());
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("1"));
   test(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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.access/index.pass.cpp

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

 
 // size_type capacity() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #include "test_macros.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, test_allocator_statistics& alloc_stats)
-{
-    alloc_stats.throw_after = 0;
+TEST_CONSTEXPR_CXX20 void test(S s, test_allocator_statistics& alloc_stats) {
 #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);
-    }
+  catch (...) {
 #endif
-    alloc_stats.throw_after = INT_MAX;
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    test_allocator_statistics alloc_stats;
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
-    S s((test_allocator<char>(&alloc_stats)));
-    test(s, alloc_stats);
-    s.assign(10, 'a');
-    s.erase(5);
-    test(s, alloc_stats);
-    s.assign(100, 'a');
-    s.erase(50);
-    test(s, alloc_stats);
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s;
+  assert(s.capacity() > 0);
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >() {
+  using S = std::basic_string<char, std::char_traits<char>, test_allocator<char> >;
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s;
-    assert(s.capacity() > 0);
-  }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.capacity/clear.pass.cpp

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

 
 // bool empty() const noexcept; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    ASSERT_NOEXCEPT(s.empty());
-    assert(s.empty() == (s.size() == 0));
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.capacity/length.pass.cpp

 
 // size_type length() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    assert(s.length() == s.size());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.capacity/max_size.pass.cpp

 // UNSUPPORTED: sanitizer-new-delete
 
 #include <string>
 #include <cassert>
 #include <new>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test1(const S& s)
-{
-    S s2(s);
-    const size_t sz = s2.max_size() - 1;
-    try { s2.resize(sz, 'x'); }
-    catch ( const std::bad_alloc & ) { return ; }
-    assert ( s2.size() ==  sz );
+TEST_CONSTEXPR_CXX20 void test1(const S& s) {
+  try {
+    s2.resize(sz, 'x');
+  } catch (const std::bad_alloc&) {
+    return;
+  }
+  assert(s2.size() == sz);
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test2(const S& s)
-{
-    S s2(s);
-    const size_t sz = s2.max_size();
-    try { s2.resize(sz, 'x'); }
-    catch ( const std::bad_alloc & ) { return ; }
-    assert ( s.size() ==  sz );
+TEST_CONSTEXPR_CXX20 void test2(const S& s) {
+  try {
+    s2.resize(sz, 'x');
+  } catch (const std::bad_alloc&) {
+    return;
+  }
+  assert(s.size() == sz);
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    assert(s.max_size() >= s.size());
-    test1(s);
-    test2(s);
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
   test(S("12345678901234567890123456789012345678901234567890"));
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
+TEST_CONSTEXPR_CXX20
+bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 #if TEST_STD_VER > 17
-constexpr bool test_constexpr() {
-  std::string str;
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string_constexpr() {
+  S str;
 
   size_t size = str.max_size();
   assert(size > 0);
+}
+
+TEST_CONSTEXPR_CXX20 bool test_constexpr() {
+  test_string_constexpr<std::string>();
+  test_string_constexpr<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 
   return true;
 }
 #endif
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   test_constexpr();
   static_assert(test_constexpr());
 #endif
 
   return 0;
 }

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

 // size_type max_size() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 #include <stdexcept>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-void
-test(const S& s)
-{
-    assert(s.max_size() >= s.size());
-    S s2(s);
-    const size_t sz = s2.max_size() + 1;
-    try { s2.resize(sz, 'x'); }
-    catch ( const std::length_error & ) { return ; }
-    assert ( false );
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  try {
+    s2.resize(sz, 'x');
+  } catch (const std::length_error&) {
+    return;
+  }
+  assert(false);
 }
 
 template <class S>
 void test_string() {
   test(S());
   test(S("123"));
   test(S("12345678901234567890123456789012345678901234567890"));
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 
   return 0;
 }

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

 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-void
-test(typename S::size_type min_cap, typename S::size_type erased_index)
-{
-    S s(min_cap, 'a');
-    s.erase(erased_index);
-    assert(s.size() == erased_index);
-    assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
+void test(typename S::size_type min_cap, typename S::size_type erased_index) {
 
-    typename S::size_type old_cap = s.capacity();
-    S s0 = s;
-    s.reserve();
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == s0);
-    assert(s.capacity() <= old_cap);
-    assert(s.capacity() >= s.size());
+  S s0                          = s;
 }
 
 template <class S>
 void test_string() {
   test<S>(0, 0);
   test<S>(10, 5);
   test<S>(100, 50);
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 
   return 0;
 }

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0}}
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
-test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg)
-{
-    S s(min_cap, 'a');
-    s.erase(erased_index);
-    assert(s.size() == erased_index);
-    assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
+test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg) {
 
 #if TEST_STD_VER > 17
-    typename S::size_type old_cap = s.capacity();
 #endif
-    S s0 = s;
-    if (res_arg <= s.max_size())
-    {
-        s.reserve(res_arg);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == s0);
-        assert(s.capacity() >= res_arg);
-        assert(s.capacity() >= s.size());
+  if (res_arg <= s.max_size()) {
 #if TEST_STD_VER > 17
-        assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
 #endif
-    }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.reserve(res_arg);
-            LIBCPP_ASSERT(s.__invariants());
-            assert(false);
-        }
-        catch (std::length_error&)
-        {
-            assert(res_arg > s.max_size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::length_error&) {
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   {
     test<S>(0, 0, 5);
     test<S>(0, 0, 10);
     test<S>(0, 0, 50);
   }
   {
     test<S>(100, 50, 5);
     test<S>(100, 50, 10);
     test<S>(100, 50, 50);
     test<S>(100, 50, 100);
     test<S>(100, 50, 1000);
     test<S>(100, 50, S::npos);
   }
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.capacity/resize_and_overwrite.pass.cpp

 // void resize_and_overwrite(size_type n, Operation op)
 
 #include <algorithm>
 #include <cassert>
 #include <string>
 
 #include "make_string.h"
 #include "test_macros.h"
+#include "test_allocator.h"
 
 template <class S>
 constexpr void test_appending(size_t k, size_t N, size_t new_capacity) {
   assert(N > k);
   assert(new_capacity >= N);
   auto s = S(k, 'a');
   s.resize_and_overwrite(new_capacity, [&](auto* p, auto n) {
     assert(n == new_capacity);
constexpr void test_truncating(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>
-constexpr bool test() {
-  using S = std::basic_string<CharT>;
+template <class CharT, template <class> class Alloc>
+constexpr bool test_string() {
+  using S = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
   test_appending<S>(10, 15, 15);
   test_appending<S>(10, 15, 20);
   test_appending<S>(10, 40, 40);
   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);
void test_value_categories() {
   s.resize_and_overwrite(10, [](char* const&, const size_t&) { return 0; });
   struct RefQualified {
     int operator()(char*, 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_string<char, std::allocator>();
+  test_string<char, fancy_pointer_allocator>();
+
+  test_string<char8_t, std::allocator>();
+  test_string<char8_t, fancy_pointer_allocator>();
+
+  test_string<char16_t, std::allocator>();
+  test_string<char16_t, fancy_pointer_allocator>();
+
+  test_string<char32_t, std::allocator>();
+  test_string<char32_t, fancy_pointer_allocator>();
+
+  static_assert(test_string<char, std::allocator>());
+  static_assert(test_string<char, fancy_pointer_allocator>());
+
+  static_assert(test_string<char8_t, std::allocator>());
+  static_assert(test_string<char8_t, fancy_pointer_allocator>());
+
+  static_assert(test_string<char16_t, std::allocator>());
+  static_assert(test_string<char16_t, fancy_pointer_allocator>());
+
+  static_assert(test_string<char32_t, std::allocator>());
+  static_assert(test_string<char32_t, fancy_pointer_allocator>());
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-  static_assert(test<wchar_t>());
+  test_string<wchar_t, std::allocator>();
+  test_string<wchar_t, fancy_pointer_allocator>();
+
+  static_assert(test_string<wchar_t, std::allocator>());
+  static_assert(test_string<wchar_t, fancy_pointer_allocator>());
 #endif
   return 0;
 }

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

 // void resize(size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::size_type n, S expected)
-{
-    if (n <= s.max_size())
-    {
-        s.resize(n);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type n, S expected) {
+  if (n <= s.max_size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.resize(n);
-            assert(false);
-        }
-        catch (std::length_error&)
-        {
-            assert(n > s.max_size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::length_error&) {
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0, S());
   test(S(), 1, S(1, '\0'));
   test(S(), 10, S(10, '\0'));
test(S("12345678901234567890123456789012345678901234567890"), 50,
         S("12345678901234567890123456789012345678901234567890"));
   test(S("12345678901234567890123456789012345678901234567890"), 60,
         S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
   test(S(), S::npos, S("not going to happen"));
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.capacity/resize_size_char.pass.cpp

 // void resize(size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::size_type n, typename S::value_type c, S expected)
-{
-    if (n <= s.max_size())
-    {
-        s.resize(n, c);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type n, typename S::value_type c, S expected) {
+  if (n <= s.max_size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.resize(n, c);
-            assert(false);
-        }
-        catch (std::length_error&)
-        {
-            assert(n > s.max_size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::length_error&) {
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0, 'a', S());
   test(S(), 1, 'a', S("a"));
   test(S(), 10, 'a', S(10, 'a'));
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
         S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
   test(S(), S::npos, 'a', S("not going to happen"));
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.capacity/shrink_to_fit.pass.cpp

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

 
 // size_type size() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s, typename S::size_type c)
-{
-    assert(s.size() == c);
+TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::size_type c) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0);
   test(S("123"), 3);
   test(S("12345678901234567890123456789012345678901234567890"), 50);
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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/T_size_size.pass.cpp

 #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
-  {
-    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;
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A  = test_allocator<char>;
+  using S  = std::basic_string<char, std::char_traits<char>, A>;
+  using SV = std::basic_string_view< char, std::char_traits<char> >;
 
-    test<S,SV>(SV(), 0, 0);
-    test<S,SV>(SV(), 0, 1);
-    test<S,SV>(SV(), 1, 0);
-    test<S,SV>(SV(), 1, 1);
-    test<S,SV>(SV(), 1, 2);
-    test<S,SV>(SV("1"), 0, 0);
-    test<S,SV>(SV("1"), 0, 1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 0);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 1);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 10);
-    test<S,SV>(SV("1234567890123456789012345678901234567890123456789012345678901234567890"), 50, 100);
+  test<S, SV>(SV(), 0, 0);
+  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));
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
+#if TEST_STD_VER >= 11
+  test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_allocator>();
 #endif
   {
-    typedef std::string S;
-    typedef std::string_view SV;
-    S s = "ABCD";
-    SV sv = "EFGH";
+    using S    = std::string;
+    using SV   = std::string_view;
+    S s        = "ABCD";
+    SV sv      = "EFGH";
     char arr[] = "IJKL";
 
-    S s1("CDEF", 4);    // calls ctor(const char *, len)
+    S s1("CDEF", 4); // calls ctor(const char *, len)
     assert(s1 == "CDEF");
 
     S s2("QRST", 0, 3); // calls ctor(string("QRST", pos, len)
     assert(s2 == "QRS");
 
-    S s3(sv, 0, std::string::npos);   // calls ctor(T, pos, npos)
+    S s3(sv, 0, std::string::npos); // calls ctor(T, pos, npos)
     assert(s3 == sv);
 
-    S s4(sv, 0, 3);   // calls ctor(T, pos, len)
+    S s4(sv, 0, 3); // calls ctor(T, pos, len)
     assert(s4 == "EFG");
 
-    S s5(arr, 0, 2);     // calls ctor(const char *, len)
+    S s5(arr, 0, 2); // calls ctor(const char *, len)
     assert(s5 == "IJ");
 
-    S s6(arr, 0);     // calls ctor(const char *, len)
+    S s6(arr, 0); // calls ctor(const char *, len)
     assert(s6 == "");
 
-    S s7(s.data(), 2);     // calls ctor(const char *, len)
+    S s7(s.data(), 2); // calls ctor(const char *, len)
     assert(s7 == "AB");
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 // explicit basic_string(const Allocator& a = Allocator()); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
     {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );

 }
 
 #endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #if TEST_STD_VER >= 11
   test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test2<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
   test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 
 // basic_string<charT,traits,Allocator>& operator=(charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s1, typename S::value_type s2)
-{
-    typedef typename S::traits_type T;
-    s1 = s2;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == 1);
-    assert(T::eq(s1[0], s2));
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, typename S::value_type s2) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 'a');
   test(S("1"), 'a');
   test(S("123456789"), 'a');
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
+
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.pass.cpp

 #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) {
 }
 
-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 CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(A()));
+  test(S("1", A()));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(A{}));
-    test(S("1", A()));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-  }
+  test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_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

 #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) {
 }
 
-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 CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+  test(S(), A());
+  test(S("1"), A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(), A());
-    test(S("1"), A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-  }
+  test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_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/copy_assignment.pass.cpp

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

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

 
 #include "test_macros.h"
 #include "test_allocator.h"
 
 #if TEST_STD_VER >= 11
 // Test the noexcept specification, which is a conforming extension
 LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<std::string>::value, "");
 LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<
-                     std::basic_string<char, std::char_traits<char>, test_allocator<char>>>::value, "");
+                         std::basic_string<char, std::char_traits<char>, test_allocator<char> > >::value,
+                     "");
+LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<
+                         std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >::value,
+                     "");
 LIBCPP_STATIC_ASSERT(!std::is_nothrow_default_constructible<
-                     std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10>>>::value, "");
+                         std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10> > >::value,
+                     "");
 #endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
   std::string str;
   assert(str.empty());
 
   return true;
 }

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

 // Test that it's possible to take the address of basic_string's destructors
 // by creating globals which will register their destructors with cxa_atexit.
 std::string s;
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 std::wstring ws;
 #endif
 
 static_assert(std::is_nothrow_destructible<std::string>::value, "");
+static_assert(
+    std::is_nothrow_destructible< std::basic_string<char, std::char_traits<char>, test_allocator<char> > >::value, "");
 static_assert(std::is_nothrow_destructible<
-                std::basic_string<char, std::char_traits<char>, test_allocator<char>>>::value, "");
-LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<
-                     std::basic_string<char, std::char_traits<char>, throwing_alloc<char>>>::value, "");
+                  std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >::value,
+              "");
+LIBCPP_STATIC_ASSERT(
+    !std::is_nothrow_destructible< std::basic_string<char, std::char_traits<char>, throwing_alloc<char> > >::value, "");
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_allocator_statistics alloc_stats;
   {
-    std::basic_string<char, std::char_traits<char>, test_allocator<char>> str2((test_allocator<char>(&alloc_stats)));
+    std::basic_string<char, std::char_traits<char>, test_allocator<char> > str2((test_allocator<char>(&alloc_stats)));
     str2 = "long long string so no SSO";
     assert(alloc_stats.alloc_count == 1);
   }
   assert(alloc_stats.alloc_count == 0);
 
   return true;
 }
 

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

 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "constexpr_char_traits.h"
 
-template <class T, class Alloc = std::allocator<T>>
+template <class T, class Alloc = std::allocator<T> >
 using BStr = std::basic_string<T, std::char_traits<T>, Alloc>;
 
 // Overloads
 //  using A = Allocator;
 //  using BS = basic_string
 //  using BSV = basic_string_view
 // ---------------
 // (1)  basic_string() - NOT TESTED

 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::basic_string w(2ull, L'b');
     ASSERT_SAME_TYPE(decltype(w), std::wstring);
     assert(w == L"bb");
 #endif
   }
   { // Testing (3) w/ allocator
     std::basic_string s(6ull, 'a', test_allocator<char>{});
-    ASSERT_SAME_TYPE(decltype(s), BStr<char,test_allocator<char>>);
+    ASSERT_SAME_TYPE(decltype(s), BStr<char, test_allocator<char> >);
     assert(s == "aaaaaa");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::basic_string w(2ull, L'b', test_allocator<wchar_t>{});
-    ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t>>);
+    ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t> >);
     assert(w == L"bb");
 #endif
   }
   { // Testing (4) w/o allocator
     const std::string sin("abc");
     std::basic_string s(sin, (size_t)1);
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "bc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     const WStr win(L"abcdef");
     std::basic_string w(win, (TestSizeT)3);
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"def");
 #endif
   }
   { // Testing (4) w/ allocator
     const std::string sin("abc");
     std::basic_string s(sin, (size_t)1, std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "bc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     const WStr win(L"abcdef");
     std::basic_string w(win, (TestSizeT)3, test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"def");
 #endif
   }
   { // Testing (5) w/o allocator
     const std::string sin("abc");
     std::basic_string s(sin, (size_t)1, (size_t)3);
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "bc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     const WStr win(L"abcdef");
     std::basic_string w(win, (TestSizeT)2, (TestSizeT)3);
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"cde");
 #endif
   }
   { // Testing (5) w/ allocator
     const std::string sin("abc");
     std::basic_string s(sin, (size_t)1, (size_t)3, std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "bc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     const WStr win(L"abcdef");
     std::basic_string w(win, (TestSizeT)2, (TestSizeT)3, test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"cde");
 #endif
   }
   { // Testing (6) w/o allocator
     std::basic_string s("abc", (size_t)2);
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "ab");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::basic_string w(L"abcdef", (size_t)3);
     ASSERT_SAME_TYPE(decltype(w), std::wstring);
     assert(w == L"abc");
 #endif
   }
   { // Testing (6) w/ allocator
     std::basic_string s("abc", (size_t)2, std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "ab");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  std::char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> >;
     std::basic_string w(L"abcdef", (TestSizeT)3, test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"abc");
 #endif
   }
   { // Testing (7) w/o allocator
     std::basic_string s("abc");
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::basic_string w(L"abcdef");
     ASSERT_SAME_TYPE(decltype(w), std::wstring);
     assert(w == L"abcdef");
 #endif
   }
   { // Testing (7) w/ allocator
     std::basic_string s("abc", std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  std::char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> >;
     std::basic_string w(L"abcdef", test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"abcdef");
 #endif
   }
   { // (8) w/o allocator
     using It = cpp17_input_iterator<const char*>;
     const char* input = "abcdef";
     std::basic_string s(It(input), It(input + 3), std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
   }
-  { // (8) w/ allocator
-    {
-      using Expect = std::basic_string<char, std::char_traits<char>, test_allocator<char>>;
-      using It = cpp17_input_iterator<const char*>;
-      const char* input = "abcdef";
-      std::basic_string s(It(input), It(input + 3), test_allocator<char>{});
-      ASSERT_SAME_TYPE(decltype(s), Expect);
-      assert(s == "abc");
+  {// (8) w/ allocator
+   {using Expect = std::basic_string<char, std::char_traits<char>, test_allocator<char> >;
+  using It          = cpp17_input_iterator<const char*>;
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
-      using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t>>;
+      using ExpectW        = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> >;
       using It = cpp17_input_iterator<const wchar_t*>;
       const wchar_t* input = L"abcdef";
       std::basic_string s(It(input), It(input + 3), test_allocator<wchar_t>{});
       ASSERT_SAME_TYPE(decltype(s), ExpectW);
       assert(s == L"abc");
     }
 #endif
   }
   { // Testing (9)
     const std::string sin("abc");
     std::basic_string s(sin);
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     const WStr win(L"abcdef");
     std::basic_string w(win);
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"abcdef");
 #endif
   }
   { // Testing (10)
     const std::string sin("abc");
     std::basic_string s(sin, std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     const WStr win(L"abcdef");
     std::basic_string w(win, test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"abcdef");
 #endif
   }
   { // Testing (11)
     std::string sin("abc");
     std::basic_string s(std::move(sin));
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     WStr win(L"abcdef");
     std::basic_string w(std::move(win));
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"abcdef");
 #endif
   }
   { // Testing (12)
     std::string sin("abc");
     std::basic_string s(std::move(sin), std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using WStr = std::basic_string<wchar_t,
-                                  constexpr_char_traits<wchar_t>,
-                                  test_allocator<wchar_t>>;
+    using WStr = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
     WStr win(L"abcdef");
     std::basic_string w(std::move(win), test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), WStr);
     assert(w == L"abcdef");
 #endif
   }
   { // Testing (13) w/o allocator
     std::basic_string s({'a', 'b', 'c'});
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::basic_string w({L'a', L'b', L'c'});
     ASSERT_SAME_TYPE(decltype(w), std::wstring);
     assert(w == L"abc");
 #endif
   }
   { // Testing (13) w/ allocator
     std::basic_string s({'a', 'b', 'c'}, test_allocator<char>{});
-    ASSERT_SAME_TYPE(decltype(s), BStr<char, test_allocator<char>>);
+    ASSERT_SAME_TYPE(decltype(s), BStr<char, test_allocator<char> >);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::basic_string w({L'a', L'b', L'c'}, test_allocator<wchar_t>{});
-    ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t>>);
+    ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t> >);
     assert(w == L"abc");
 #endif
   }
   { // Testing (14) w/o allocator
     std::string_view sv("abc");
     std::basic_string s(sv);
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using Expect = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>>;
-    std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t>> BSV(L"abcdef");
+    using Expect = std::basic_string<wchar_t, constexpr_char_traits<wchar_t> >;
+    std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t> > BSV(L"abcdef");
     std::basic_string w(BSV);
     ASSERT_SAME_TYPE(decltype(w), Expect);
     assert(w == L"abcdef");
 #endif
   }
   { // Testing (14) w/ allocator
-    using ExpectS = std::basic_string<char, std::char_traits<char>, test_allocator<char>>;
+    using ExpectS = std::basic_string<char, std::char_traits<char>, test_allocator<char> >;
     std::string_view sv("abc");
     std::basic_string s(sv, test_allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), ExpectS);
     assert(s == "abc");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using ExpectW = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>,
-                                      test_allocator<wchar_t>>;
-    std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t>> BSV(L"abcdef");
+    using ExpectW = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>, test_allocator<wchar_t> >;
+    std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t> > BSV(L"abcdef");
     std::basic_string w(BSV, test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), ExpectW);
     assert(w == L"abcdef");
 #endif
   }
   { // Testing (15) w/o allocator
     std::string s0("abc");
     std::basic_string s(s0, 1, 1);
     ASSERT_SAME_TYPE(decltype(s), std::string);
     assert(s == "b");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::wstring w0(L"abcdef");
     std::basic_string w(w0, 2, 2);
     ASSERT_SAME_TYPE(decltype(w), std::wstring);
     assert(w == L"cd");
 #endif
   }
   { // Testing (15) w/ allocator
-    using ExpectS = std::basic_string<char, std::char_traits<char>, test_allocator<char>>;
+    using ExpectS = std::basic_string<char, std::char_traits<char>, test_allocator<char> >;
     ExpectS s0("abc");
     std::basic_string s(s0, 1, 1, test_allocator<char>{4});
     ASSERT_SAME_TYPE(decltype(s), ExpectS);
     assert(s == "b");
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t>>;
+    using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> >;
     ExpectW w0(L"abcdef");
     std::basic_string w(w0, 2, 2, test_allocator<wchar_t>{6});
     ASSERT_SAME_TYPE(decltype(w), ExpectW);
     assert(w == L"cd");
 #endif
   }
 
   return true;

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() {
-  {
-    std::string s = {'a', 'b', 'c'};
-    assert(s == "abc");
-  }
+template <template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void
+test_string(){{std::basic_string<char, std::char_traits<char>, Alloc<char> > s = {'a', 'b', 'c'};
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  {
-    std::wstring s;
-    s = {L'a', L'b', L'c'};
-    assert(s == L"abc");
-  }
+  std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> > s;
 #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
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::allocator>();
+  test_string<min_allocator>();
+  test_string<fancy_pointer_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/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"
+#include "test_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s;
-    s = {'a', 'b', 'c'};
-    assert(s == "abc");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s;
-    s = {'a', 'b', 'c'};
-    assert(s == "abc");
-  }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_case() {
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_case<std::string>();
+  test_case<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_case<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+
   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, a);
 
-    test(s, s+1);
-    test(s, s+1, A(2));
+  test(s, s + 1);
+  test(s, s + 1, a);
 
-    test(s, s+10);
-    test(s, s+10, A(2));
+  test(s, s + 10);
+  test(s, s + 10, a);
 
-    test(s, s+50);
-    test(s, s+50, A(2));
+  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(2));
+  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(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), 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), 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), 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>());
+  test<fancy_pointer_allocator<char> >(fancy_pointer_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/iter_alloc_deduction.pass.cpp

 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 class NotAnIterator {};
-using NotAnInputIterator = std::back_insert_iterator<std::basic_string<char16_t>>;
+using NotAnInputIterator = std::back_insert_iterator<std::basic_string<char16_t> >;
 
 template <typename T>
-struct NotAnAllocator { typedef T value_type; };
+struct NotAnAllocator {
+  typedef T value_type;
+};
 
 template <class Iter, class Alloc, class = void>
-struct CanDeduce : std::false_type { };
+struct CanDeduce : std::false_type {};
 
 template <class Iter, class Alloc>
-struct CanDeduce<Iter, Alloc, decltype((void)
-  std::basic_string{std::declval<Iter>(), std::declval<Iter>(), std::declval<Alloc>()}
-)> : std::true_type { };
+struct CanDeduce<Iter,
+                 Alloc,
+                 decltype((void)std::basic_string{std::declval<Iter>(), std::declval<Iter>(), std::declval<Alloc>()})>
+    : std::true_type {};
 
-static_assert( CanDeduce<int*, std::allocator<int>>::value);
-static_assert(!CanDeduce<NotAnIterator, std::allocator<char>>::value);
-static_assert(!CanDeduce<NotAnInputIterator, std::allocator<char16_t>>::value);
-static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t>>::value);
+static_assert(CanDeduce<int*, std::allocator<int> >::value);
+static_assert(!CanDeduce<NotAnIterator, std::allocator<char> >::value);
+static_assert(!CanDeduce<NotAnInputIterator, std::allocator<char16_t> >::value);
+static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t> >::value);
 
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void
+test_string(const CharT* s,
+            const std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >& s1,
+            const std::size_t string_size) {
+  using S = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  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() == string_size);
+  assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
+  const std::size_t string_size = 10;
   {
     const char* s = "12345678901234";
-    std::basic_string s1(s, s+10);  // Can't use {} here
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1(s, s + string_size); // Can't use {} here
+    test_string<char, std::allocator>(s, s1, string_size);
   }
   {
     const char* s = "12345678901234";
-    std::basic_string s1{s, s+10, std::allocator<char>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + 10, std::allocator<char>{}};
+    test_string<char, std::allocator>(s, s1, string_size);
   }
   {
     const wchar_t* s = L"12345678901234";
-    std::basic_string s1{s, s+10, test_allocator<wchar_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + string_size, test_allocator<wchar_t>{}};
+    test_string<wchar_t, test_allocator>(s, s1, string_size);
   }
   {
     const char16_t* s = u"12345678901234";
-    std::basic_string s1{s, s+10, min_allocator<char16_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + string_size, min_allocator<char16_t>{}};
+    test_string<char16_t, min_allocator>(s, s1, string_size);
+  }
+  {
+    const char16_t* s = u"12345678901234";
+    std::basic_string s1{s, s + string_size, fancy_pointer_allocator<char16_t>{}};
+    test_string<char16_t, fancy_pointer_allocator>(s, s1, string_size);
   }
   {
     const char32_t* s = U"12345678901234";
-    std::basic_string s1{s, s+10, explicit_allocator<char32_t>{}};
-    using S = decltype(s1); // what type did we get?
-    static_assert(std::is_same_v<S::value_type,                        char32_t>,  "");
-    static_assert(std::is_same_v<S::traits_type,      std::char_traits<char32_t>>, "");
-    static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
-    assert(s1.size() == 10);
-    assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
+    std::basic_string s1{s, s + string_size, explicit_allocator<char32_t>{}};
+    test_string<char32_t, explicit_allocator>(s, s1, string_size);
+  }
+  {
+    const char32_t* s = U"12345678901234";
+    std::basic_string s1{s, s + string_size, fancy_pointer_allocator<char32_t>{}};
+    test_string<char32_t, fancy_pointer_allocator>(s, s1, string_size);
   }
 
   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

 #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) {
 }
 
-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 CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  typedef Alloc<CharT> A;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
 
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+  test(S(A(3)));
+  test(S("1", A(5)));
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
+  test_string<char, fancy_pointer_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/move_alloc.pass.cpp

 #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, const typename S::allocator_type& a)
-{
-    S s1 = s0;
-    S s2(std::move(s0), a);
-    LIBCPP_ASSERT(s2.__invariants());
-    LIBCPP_ASSERT(s0.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == a);
+TEST_CONSTEXPR_CXX20 void test(S s0, const typename S::allocator_type& a) {
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+#if TEST_STD_VER > 14
+  static_assert((noexcept(S{})), "");
+#elif TEST_STD_VER >= 11
+  static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "");
+#endif
+  test(S(), A());
+  test(S("1"), A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   test_allocator_statistics alloc_stats;
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
+  {
 #if TEST_STD_VER > 14
-    static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "");
 #elif TEST_STD_VER >= 11
-    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "");
 #endif
     test(S(), A(3, &alloc_stats));
     test(S("1"), A(5, &alloc_stats));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7, &alloc_stats));
   }
 
-    int alloc_count = alloc_stats.alloc_count;
   {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
-    static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "");
 #elif TEST_STD_VER >= 11
-    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "");
 #endif
-    S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe", A(&alloc_stats));
-    S s2 (std::move(s1), A(1, &alloc_stats));
+    S s1("Twas brillig, and the slivy toves did gyre and gymbal in the wabe", A(&alloc_stats));
+    S s2(std::move(s1), A(1, &alloc_stats));
   }
-    assert ( alloc_stats.alloc_count == alloc_count );
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-#if TEST_STD_VER > 14
-    static_assert((noexcept(S{})), "" );
-#elif TEST_STD_VER >= 11
-    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
-#endif
-    test(S(), A());
-    test(S("1"), A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-  }
+  assert(alloc_stats.alloc_count == alloc_count);
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, test_allocator>();
+  test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_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/move_assign_noexcept.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
 template <class T>
-struct some_alloc
-{
-    typedef T value_type;
-    some_alloc(const some_alloc&);
-    T *allocate(size_t);
+struct some_alloc {
+  T* allocate(size_t);
 };
 
 template <class T>
-struct some_alloc2
-{
-    typedef T value_type;
+struct some_alloc2 {
 
-    some_alloc2() {}
-    some_alloc2(const some_alloc2&);
-    T *allocate(size_t);
-    void deallocate(void*, unsigned) {}
+  T* allocate(size_t);
 
-    typedef std::false_type propagate_on_container_move_assignment;
-    typedef std::true_type is_always_equal;
 };
 
 template <class T>
-struct some_alloc3
-{
-    typedef T value_type;
+struct some_alloc3 {
 
-    some_alloc3() {}
-    some_alloc3(const some_alloc3&);
-    T *allocate(size_t);
-    void deallocate(void*, unsigned) {}
+  T* allocate(size_t);
 
-    typedef std::false_type propagate_on_container_move_assignment;
-    typedef std::false_type is_always_equal;
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string C;
     static_assert(std::is_nothrow_move_assignable<C>::value, "");
   }
   {
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
+    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > C;
     static_assert(!std::is_nothrow_move_assignable<C>::value, "");
   }
   {
-    typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
+    typedef std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > C;
+    static_assert(std::is_nothrow_move_assignable<C>::value, "");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc<char> > C;
 #if TEST_STD_VER > 14
     // if the allocators are always equal, then the move assignment can be noexcept
-    static_assert( std::is_nothrow_move_assignable<C>::value, "");
+    static_assert(std::is_nothrow_move_assignable<C>::value, "");
 #else
-      static_assert(!std::is_nothrow_move_assignable<C>::value, "");
 #endif
   }
 #if TEST_STD_VER > 14
   {
     //  POCMA is false, always equal
-    typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
-    static_assert( std::is_nothrow_move_assignable<C>::value, "");
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char> > C;
+    static_assert(std::is_nothrow_move_assignable<C>::value, "");
   }
   {
     //  POCMA is false, not always equal
-    typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char>> C;
+    typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char> > C;
     static_assert(!std::is_nothrow_move_assignable<C>::value, "");
   }
 #endif
 
   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_assignment.pass.cpp

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

 // This tests a conforming extension
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::string C;
-        static_assert(std::is_nothrow_move_constructible<C>::value, "");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
-        static_assert(std::is_nothrow_move_constructible<C>::value, "");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10>> C;
+int main(int, char**) {
+    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > C;
+    typedef std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > C;
+    static_assert(std::is_nothrow_move_constructible<C>::value, "");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10> > C;
 #if TEST_STD_VER <= 14
-        static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #else
-        static_assert( std::is_nothrow_move_constructible<C>::value, "");
+    static_assert(std::is_nothrow_move_constructible<C>::value, "");
 #endif
-    }
 
   return 0;
 }

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

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
-TEST_CONSTEXPR_CXX20 void
-test(const charT* s)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    std::size_t n = T::length(s);
-    S s2(s);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(const charT* s) {
 }
 
-template <class charT, class A>
-TEST_CONSTEXPR_CXX20 void
-test(const charT* s, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
-    std::size_t n = T::length(s);
-    S s2(s, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+template <class charT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const charT* s, const Alloc& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> S;
 }
 
-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("", a);
 
-    test("1");
-    test("1", A(2));
+  test("1", a);
 
-    test("1234567980");
-    test("1234567980", A(2));
+  test("1234567980", 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("123456798012345679801234567980123456798012345679801234567980", a);
 
-    test("1234567980");
-    test("1234567980", A());
-
-    test("123456798012345679801234567980123456798012345679801234567980");
-    test("123456798012345679801234567980123456798012345679801234567980", 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>());
+  test<fancy_pointer_allocator<char> >(fancy_pointer_allocator<char>());
 #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/pointer_assignment.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   operator=(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s1, const typename S::value_type* s2)
-{
-    typedef typename S::traits_type T;
-    s1 = s2;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == T::length(s2));
-    assert(T::compare(s1.data(), s2, s1.size()) == 0);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, const typename S::value_type* s2) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "");
   test(S("1"), "");
   test(S(), "1");
   test(S("1"), "2");
   test(S("1"), "2");
 
-  test(S(),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-  test(S("123456789"),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+  test(S(), "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+  test(S("123456789"), "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
-          "1234567890123456789012345678901234567890123456789012345678901234567890"),
-        "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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/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;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    S s2(s, n);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+template <class CharT>
+TEST_CONSTEXPR_CXX20 void test(const CharT* s, unsigned n) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT> > S;
 }
 
-template <class charT, class A>
-TEST_CONSTEXPR_CXX20 void
-test(const charT* s, unsigned n, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
-    S s2(s, n, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+template <class CharT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(const CharT* s, unsigned n, const Alloc& a) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc> S;
 }
 
-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("", 0, a);
 
-    test("1", 1);
-    test("1", 1, A(2));
+  test("1", 1, a);
 
-    test("1234567980", 10);
-    test("1234567980", 10, A(2));
+  test("1234567980", 10, 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("123456798012345679801234567980123456798012345679801234567980", 60, a);
 
-    test("1234567980", 10);
-    test("1234567980", 10, A());
-
-    test("123456798012345679801234567980123456798012345679801234567980", 60);
-    test("123456798012345679801234567980123456798012345679801234567980", 60, 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>());
+  test<fancy_pointer_allocator<char> >(fancy_pointer_allocator<char>());
 #endif
 
 #if TEST_STD_VER >= 11
   {   // LWG 2946
     std::string s({"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");
   }
 #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/size_char_alloc.pass.cpp

 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
-TEST_CONSTEXPR_CXX20 void
-test(unsigned n, charT c)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(n, c);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    for (unsigned i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(unsigned n, charT c) {
 }
 
-template <class charT, class A>
-TEST_CONSTEXPR_CXX20 void
-test(unsigned n, charT c, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(n, c, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    for (unsigned i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+template <class charT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(unsigned n, charT c, const Alloc& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, Alloc> S;
 }
 
 template <class Tp>
-TEST_CONSTEXPR_CXX20 void
-test(Tp n, Tp c)
-{
-    typedef char charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(n, c);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(n));
-    for (int i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c) {
 }
 
 template <class Tp, class A>
-TEST_CONSTEXPR_CXX20 void
-test(Tp n, Tp c, const A& a)
-{
-    typedef char charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(n, c, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(n));
-    for (int i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c, const A& a) {
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-
-    test(0, 'a');
-    test(0, 'a', A(2));
+template <class A>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  test(0, 'a', A());
 
-    test(1, 'a');
-    test(1, 'a', A(2));
+  test(1, 'a', A());
 
-    test(10, 'a');
-    test(10, 'a', A(2));
+  test(10, 'a', A());
 
-    test(100, 'a');
-    test(100, 'a', A(2));
+  test(100, 'a', 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(static_cast<char>(100), static_cast<char>(65), A());
 
-    test(0, 'a');
-    test(0, 'a', A());
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<test_allocator<char> >() {
+  using A = test_allocator<char>;
+  test(0, 'a', A(2));
 
-    test(1, 'a');
-    test(1, 'a', A());
+  test(1, 'a', A(2));
 
-    test(10, 'a');
-    test(10, 'a', A());
+  test(10, 'a', A(2));
 
-    test(100, 'a');
-    test(100, 'a', A());
+  test(100, 'a', A(2));
 
-    test(static_cast<char>(100), static_cast<char>(65));
-    test(static_cast<char>(100), static_cast<char>(65), A());
-  }
+  test(static_cast<char>(100), static_cast<char>(65), A(3));
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<test_allocator<char> >();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator<char> >();
+  test_string<fancy_pointer_allocator<char> >();
 #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/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;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
+template <class CharT>
+TEST_CONSTEXPR_CXX20 void test(std::basic_string_view<CharT> sv) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT> > S;
   {
     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.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.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;
-    typedef typename S::traits_type T;
+template <class CharT, class Alloc>
+TEST_CONSTEXPR_CXX20 void test(std::basic_string_view<CharT> sv, const Alloc& a) {
+  typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc> S;
   {
     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(SV(""), a);
 
-    test(SV("1"));
-    test(SV("1") ,A(2));
+  test(SV("1"), a);
 
-    test(SV("1234567980"));
-    test(SV("1234567980"), A(2));
+  test(SV("1234567980"), 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(SV("123456798012345679801234567980123456798012345679801234567980"), 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<test_allocator<char> >(test_allocator<char>(2));
+#if TEST_STD_VER >= 11
+  test_string<min_allocator<char> >(min_allocator<char>());
+  test_string<fancy_pointer_allocator<char> >(fancy_pointer_allocator<char>());
 #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/string_view_assignment.pass.cpp

 
 // basic_string<charT,traits,Allocator>& operator=(basic_string_view<charT, traits> sv); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(S s1, SV sv)
-{
-    typedef typename S::traits_type T;
-    s1 = sv;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == sv.size());
-    assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, SV sv) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   typedef std::string_view SV;
   test(S(), SV(""));
   test(S("1"), SV(""));
   test(S(), SV("1"));
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
           "1234567890123456789012345678901234567890123456789012345678901234567890"),
         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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/string_view_deduction.pass.cpp

 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);
+static_assert(CanDeduce<std::string_view, std::allocator<char> >::value);
 static_assert(!CanDeduce<std::string_view, NotAnAllocator>::value);
 
 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>>, "");
+    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);
   }
 
   {
     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>>, "");
+    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);
   }
 #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>>, "");
+    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);
   }
 #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>>, "");
+    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);
   }
+  {
+    std::u8string_view sv = u8"12345678901234";
+    std::basic_string s1{sv, fancy_pointer_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, fancy_pointer_allocator<char8_t> >, "");
+    assert(s1.size() == sv.size());
+    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+  }
 #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>>, "");
+    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);
   }
   {
+    std::u16string_view sv = u"12345678901234";
+    std::basic_string s1{sv, fancy_pointer_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, fancy_pointer_allocator<char16_t> >, "");
+    assert(s1.size() == sv.size());
+    assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
+  }
+  {
     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>>, "");
+    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);
   }
 
   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_size_size_deduction.pass.cpp

 #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 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_string(const std::basic_string_view<CharT, std::char_traits<CharT> >& sv,
+            const std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >& s1,
+            const std::size_t string_size) {
+  using S = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  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() == string_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, 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_string<char, std::allocator>(sv, s1, 4);
   }
 
   {
     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_string<char, std::allocator>(sv, s1, 4);
   }
 #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_string<wchar_t, test_allocator>(sv, s1, 4);
   }
 #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_string<char8_t, min_allocator>(sv, s1, 4);
+  }
+  {
+    std::u8string_view sv = u8"12345678901234";
+    std::basic_string s1{sv, 0, 4, fancy_pointer_allocator<char8_t>{}};
+    test_string<char8_t, fancy_pointer_allocator>(sv, s1, 4);
   }
 #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_string<char16_t, min_allocator>(sv, s1, 4);
+  }
+  {
+    std::u16string_view sv = u"12345678901234";
+    std::basic_string s1{sv, 0, 4, fancy_pointer_allocator<char16_t>{}};
+    test_string<char16_t, fancy_pointer_allocator>(sv, s1, 4);
   }
   {
     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_string<char32_t, explicit_allocator>(sv, s1, 4);
   }
 
   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/substr.pass.cpp

 #include <scoped_allocator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S str, unsigned pos)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos) {
 
-    if (pos <= str.size())
-    {
-        S s2(str, pos);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = str.size() - pos;
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+  if (pos <= str.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(str, pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S str, unsigned pos, unsigned n)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    if (pos <= str.size())
-    {
-        S s2(str, pos, n);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos, unsigned n) {
+  if (pos <= str.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(str, pos, n);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
-{
-    typedef typename S::traits_type T;
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a) {
 
-    if (pos <= str.size())
-    {
-        S s2(str, pos, n, a);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == a);
-        assert(s2.capacity() >= s2.size());
-    }
+  if (pos <= str.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            S s2(str, pos, n, a);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
-void test_lwg2583()
-{
+void test_lwg2583() {
 #if TEST_STD_VER >= 11 && !defined(TEST_HAS_NO_EXCEPTIONS)
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringA;
-    std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA>>> vs;
-    StringA s{"1234"};
-    vs.emplace_back(s, 2);
+  typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > StringA;
+  std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA> > > vs;
 
-    try { vs.emplace_back(s, 5); }
-    catch (const std::out_of_range&) { return; }
-    assert(false);
+  try {
+    vs.emplace_back(s, 5);
+  } catch (const std::out_of_range&) {
+    return;
+  }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = Alloc<CharT>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, A>;
+
+  test(S(A()), 0);
+  test(S(A()), 1);
+  test(S("1", A()), 0);
+  test(S("1", A()), 1);
+  test(S("1", A()), 2);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 5);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 500);
+
+  test(S(A()), 0, 0);
+  test(S(A()), 0, 1);
+  test(S(A()), 1, 0);
+  test(S(A()), 1, 1);
+  test(S(A()), 1, 2);
+  test(S("1", A()), 0, 0);
+  test(S("1", A()), 0, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10);
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100);
+
+  test(S(A()), 0, 0, A());
+  test(S(A()), 0, 1, A());
+  test(S(A()), 1, 0, A());
+  test(S(A()), 1, 1, A());
+  test(S(A()), 1, 2, A());
+  test(S("1", A()), 0, 0, A());
+  test(S("1", A()), 0, 1, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
+  test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
 
-    test(S(A(3)), 0);
-    test(S(A(3)), 1);
-    test(S("1", A(5)), 0);
-    test(S("1", A(5)), 1);
-    test(S("1", A(5)), 2);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 5);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 500);
 
-    test(S(A(3)), 0, 0);
-    test(S(A(3)), 0, 1);
-    test(S(A(3)), 1, 0);
-    test(S(A(3)), 1, 1);
-    test(S(A(3)), 1, 2);
-    test(S("1", A(5)), 0, 0);
-    test(S("1", A(5)), 0, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100);
 
-    test(S(A(3)), 0, 0, A(4));
-    test(S(A(3)), 0, 1, A(4));
-    test(S(A(3)), 1, 0, A(4));
-    test(S(A(3)), 1, 1, A(4));
-    test(S(A(3)), 1, 2, A(4));
-    test(S("1", A(5)), 0, 0, A(6));
-    test(S("1", A(5)), 0, 1, A(6));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0, A(8));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1, A(8));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
-  }
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
   {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-
-    test(S(A()), 0);
-    test(S(A()), 1);
-    test(S("1", A()), 0);
-    test(S("1", A()), 1);
-    test(S("1", A()), 2);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 5);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 500);
-
-    test(S(A()), 0, 0);
-    test(S(A()), 0, 1);
-    test(S(A()), 1, 0);
-    test(S(A()), 1, 1);
-    test(S(A()), 1, 2);
-    test(S("1", A()), 0, 0);
-    test(S("1", A()), 0, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10);
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100);
-
-    test(S(A()), 0, 0, A());
-    test(S(A()), 0, 1, A());
-    test(S(A()), 1, 0, A());
-    test(S(A()), 1, 1, A());
-    test(S(A()), 1, 2, A());
-    test(S("1", A()), 0, 0, A());
-    test(S("1", A()), 0, 1, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
+    test_string<char, min_allocator>();
+    test_string<char, fancy_pointer_allocator>();
   }
 #endif
 
   return true;
 }
 
-int main(int, char**)
-{
+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

 // <string>
 
 // constexpr bool contains(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test()
-{
-    using S = std::string;
-
-    S s1 {};
-    S s2 {"abcde", 5};
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s1{};
+  S s2{"abcde", 5};
 
-    ASSERT_NOEXCEPT(s1.contains('e'));
 
-    assert(!s1.contains('c'));
-    assert(!s1.contains('e'));
-    assert(!s1.contains('x'));
-    assert( s2.contains('c'));
-    assert( s2.contains('e'));
-    assert(!s2.contains('x'));
+  assert(s2.contains('c'));
+  assert(s2.contains('e'));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 
-    return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 // <string>
 
 // constexpr bool contains(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test()
-{
-    using S = std::string;
-
-    const char* s = "abcde";
-    S s0;
-    S s1 {s + 4, 1};
-    S s3 {s + 2, 3};
-    S sNot {"xyz", 3};
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s1{s + 4, 1};
+  S s3{s + 2, 3};
+  S sNot{"xyz", 3};
 
-    assert(s0.contains(""));
-    assert(!s0.contains("e"));
 
-    assert( s1.contains(""));
-    assert(!s1.contains("d"));
-    assert( s1.contains("e"));
-    assert(!s1.contains("de"));
-    assert(!s1.contains("cd"));
-    assert(!s1.contains("cde"));
-    assert(!s1.contains("bcde"));
-    assert(!s1.contains("abcde"));
-    assert(!s1.contains("xyz"));
+  assert(s1.contains(""));
+  assert(s1.contains("e"));
 
-    assert( s3.contains(""));
-    assert( s3.contains("d"));
-    assert( s3.contains("e"));
-    assert( s3.contains("de"));
-    assert( s3.contains("cd"));
-    assert(!s3.contains("ce"));
-    assert( s3.contains("cde"));
-    assert(!s3.contains("edc"));
-    assert(!s3.contains("bcde"));
-    assert(!s3.contains("abcde"));
-    assert(!s3.contains("xyz"));
+  assert(s3.contains(""));
+  assert(s3.contains("d"));
+  assert(s3.contains("e"));
+  assert(s3.contains("de"));
+  assert(s3.contains("cd"));
+  assert(s3.contains("cde"));
 
-    assert( sNot.contains(""));
-    assert(!sNot.contains("d"));
-    assert(!sNot.contains("e"));
-    assert(!sNot.contains("de"));
-    assert(!sNot.contains("cd"));
-    assert(!sNot.contains("cde"));
-    assert(!sNot.contains("bcde"));
-    assert(!sNot.contains("abcde"));
-    assert( sNot.contains("xyz"));
-    assert(!sNot.contains("zyx"));
+  assert(sNot.contains(""));
+  assert(sNot.contains("xyz"));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 
-    return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 // <string>
 
 // constexpr bool contains(basic_string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test()
-{
-    using S = std::string;
-    using SV = std::string_view;
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using S  = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV = std::basic_string_view< CharT, std::char_traits<CharT> >;
 
-    const char* s = "abcde";
-    S s0;
-    S s1 {s + 1, 1};
-    S s3 {s + 1, 3};
-    S s5 {s    , 5};
-    S sNot {"xyz", 3};
+  S s1{s + 1, 1};
+  S s3{s + 1, 3};
+  S s5{s, 5};
+  S sNot{"xyz", 3};
 
-    SV sv0;
-    SV sv1 {s + 1, 1};
-    SV sv2 {s + 1, 2};
-    SV sv3 {s + 1, 3};
-    SV sv4 {s + 1, 4};
-    SV sv5 {s    , 5};
-    SV svNot  {"xyz", 3};
-    SV svNot2 {"bd" , 2};
-    SV svNot3 {"dcb", 3};
+  SV sv1{s + 1, 1};
+  SV sv2{s + 1, 2};
+  SV sv3{s + 1, 3};
+  SV sv4{s + 1, 4};
+  SV sv5{s, 5};
+  SV svNot{"xyz", 3};
+  SV svNot2{"bd", 2};
+  SV svNot3{"dcb", 3};
 
-    ASSERT_NOEXCEPT(s0.contains(sv0));
 
-    assert( s0.contains(sv0));
-    assert(!s0.contains(sv1));
+  assert(s0.contains(sv0));
 
-    assert( s1.contains(sv0));
-    assert( s1.contains(sv1));
-    assert(!s1.contains(sv2));
-    assert(!s1.contains(sv3));
-    assert(!s1.contains(sv4));
-    assert(!s1.contains(sv5));
-    assert(!s1.contains(svNot));
-    assert(!s1.contains(svNot2));
-    assert(!s1.contains(svNot3));
+  assert(s1.contains(sv0));
+  assert(s1.contains(sv1));
 
-    assert( s3.contains(sv0));
-    assert( s3.contains(sv1));
-    assert( s3.contains(sv2));
-    assert( s3.contains(sv3));
-    assert(!s3.contains(sv4));
-    assert(!s3.contains(sv5));
-    assert(!s3.contains(svNot));
-    assert(!s3.contains(svNot2));
-    assert(!s3.contains(svNot3));
+  assert(s3.contains(sv0));
+  assert(s3.contains(sv1));
+  assert(s3.contains(sv2));
+  assert(s3.contains(sv3));
 
-    assert( s5.contains(sv0));
-    assert( s5.contains(sv1));
-    assert( s5.contains(sv2));
-    assert( s5.contains(sv3));
-    assert( s5.contains(sv4));
-    assert( s5.contains(sv5));
-    assert(!s5.contains(svNot));
-    assert(!s5.contains(svNot2));
-    assert(!s5.contains(svNot3));
+  assert(s5.contains(sv0));
+  assert(s5.contains(sv1));
+  assert(s5.contains(sv2));
+  assert(s5.contains(sv3));
+  assert(s5.contains(sv4));
+  assert(s5.contains(sv5));
 
-    assert( sNot.contains(sv0));
-    assert(!sNot.contains(sv1));
-    assert(!sNot.contains(sv2));
-    assert(!sNot.contains(sv3));
-    assert(!sNot.contains(sv4));
-    assert(!sNot.contains(sv5));
-    assert( sNot.contains(svNot));
-    assert(!sNot.contains(svNot2));
-    assert(!sNot.contains(svNot3));
+  assert(sNot.contains(sv0));
+  assert(sNot.contains(svNot));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, fancy_pointer_allocator>();
 
-    return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 // <string>
 
 // constexpr bool ends_with(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    S  s1 {};
-    S  s2 { "abcde", 5 };
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s1{};
+  S s2{"abcde", 5};
 
-    ASSERT_NOEXCEPT(s1.ends_with('e'));
 
-    assert (!s1.ends_with('e'));
-    assert (!s1.ends_with('x'));
-    assert ( s2.ends_with('e'));
-    assert (!s2.ends_with('x'));
-  }
+  assert(!s1.ends_with('e'));
+  assert(!s1.ends_with('x'));
+  assert(s2.ends_with('e'));
+  assert(!s2.ends_with('x'));
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 // <string>
 
 // constexpr bool ends_with(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    const char *s = "abcde";
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  const char* s = "abcde";
 
-    S   s0;
-    S   s1  { s + 4, 1 };
-    S   s2  { s + 3, 2 };
+  S s0;
+  S s1{s + 4, 1};
+  S s2{s + 3, 2};
   //  S   s3  { s + 2, 3 };
   //  S   s4  { s + 1, 4 };
   //  S   s5  { s,     5 };
-    S  sNot { "def", 3 };
+  S sNot{"def", 3};
 
-    LIBCPP_ASSERT_NOEXCEPT(s0.ends_with(""));
 
-    assert ( s0.ends_with(""));
-    assert (!s0.ends_with("e"));
+  assert(s0.ends_with(""));
+  assert(!s0.ends_with("e"));
 
-    assert ( s1.ends_with(""));
-    assert ( s1.ends_with("e"));
-    assert (!s1.ends_with("de"));
-    assert (!s1.ends_with("cde"));
-    assert (!s1.ends_with("bcde"));
-    assert (!s1.ends_with("abcde"));
-    assert (!s1.ends_with("def"));
+  assert(s1.ends_with(""));
+  assert(s1.ends_with("e"));
+  assert(!s1.ends_with("de"));
+  assert(!s1.ends_with("cde"));
+  assert(!s1.ends_with("bcde"));
+  assert(!s1.ends_with("abcde"));
+  assert(!s1.ends_with("def"));
 
-    assert ( s2.ends_with(""));
-    assert ( s2.ends_with("e"));
-    assert ( s2.ends_with("de"));
-    assert (!s2.ends_with("cde"));
-    assert (!s2.ends_with("bcde"));
-    assert (!s2.ends_with("abcde"));
-    assert (!s2.ends_with("def"));
+  assert(s2.ends_with(""));
+  assert(s2.ends_with("e"));
+  assert(s2.ends_with("de"));
+  assert(!s2.ends_with("cde"));
+  assert(!s2.ends_with("bcde"));
+  assert(!s2.ends_with("abcde"));
+  assert(!s2.ends_with("def"));
 
-    assert ( sNot.ends_with(""));
-    assert (!sNot.ends_with("e"));
-    assert (!sNot.ends_with("de"));
-    assert (!sNot.ends_with("cde"));
-    assert (!sNot.ends_with("bcde"));
-    assert (!sNot.ends_with("abcde"));
-    assert ( sNot.ends_with("def"));
-  }
+  assert(sNot.ends_with(""));
+  assert(!sNot.ends_with("e"));
+  assert(!sNot.ends_with("de"));
+  assert(!sNot.ends_with("cde"));
+  assert(!sNot.ends_with("bcde"));
+  assert(!sNot.ends_with("abcde"));
+  assert(sNot.ends_with("def"));
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+
   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

 // <string>
 
 // constexpr bool ends_with(basic_string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    typedef std::string_view SV;
-    const char *s = "abcde";
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using S       = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV      = std::basic_string_view< CharT, std::char_traits<CharT> >;
+  const char* s = "abcde";
 
-    S   s0;
-    S   s1  { s + 4, 1 };
-    S   s2  { s + 3, 2 };
+  S s0;
+  S s1{s + 4, 1};
+  S s2{s + 3, 2};
   //  S   s3  { s + 2, 3 };
   //  S   s4  { s + 1, 4 };
   //  S   s5  { s,     5 };
-    S  sNot { "def", 3 };
+  S 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 };
+  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(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(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(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));
-  }
+  assert(sNot.ends_with(sv0));
+  assert(!sNot.ends_with(sv1));
+  assert(!sNot.ends_with(sv2));
+  assert(!sNot.ends_with(sv3));
+  assert(!sNot.ends_with(sv4));
+  assert(!sNot.ends_with(sv5));
+  assert(sNot.ends_with(svNot));
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, fancy_pointer_allocator>();
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 //       iterator begin(); // constexpr since C++20
 // const_iterator begin() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::iterator b = s.begin();
-    typename S::const_iterator cb = cs.begin();
-    if (!s.empty())
-    {
-        assert(*b == s[0]);
-    }
-    assert(b == cb);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                   = s;
+  typename S::iterator b        = s.begin();
+  if (!s.empty()) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.iterators/cbegin.pass.cpp

 
 // const_iterator cbegin() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_iterator cb = s.cbegin();
-    if (!s.empty())
-    {
-        assert(*cb == s[0]);
-    }
-    assert(cb == s.begin());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  if (!s.empty()) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.iterators/cend.pass.cpp

 
 // const_iterator cend() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_iterator ce = s.cend();
-    assert(ce == s.end());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.iterators/crbegin.pass.cpp

 
 // const_reverse_iterator crbegin() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_reverse_iterator cb = s.crbegin();
-    if (!s.empty())
-    {
-        assert(*cb == s.back());
-    }
-    assert(cb == s.rbegin());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  if (!s.empty()) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.iterators/crend.pass.cpp

 
 // const_reverse_iterator crend() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(const S& s)
-{
-    typename S::const_reverse_iterator ce = s.crend();
-    assert(ce == s.rend());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.iterators/end.pass.cpp

 // const_iterator end() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::iterator e = s.end();
-    typename S::const_iterator ce = cs.end();
-    if (s.empty())
-    {
-        assert(e == s.begin());
-        assert(ce == cs.begin());
-    }
-    assert(static_cast<std::size_t>(e - s.begin()) == s.size());
-    assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                   = s;
+  typename S::iterator e        = s.end();
+  if (s.empty()) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.iterators/rbegin.pass.cpp

 //       reverse_iterator rbegin(); // constexpr since C++20
 // const_reverse_iterator rbegin() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::reverse_iterator b = s.rbegin();
-    typename S::const_reverse_iterator cb = cs.rbegin();
-    if (!s.empty())
-    {
-        assert(*b == s.back());
-    }
-    assert(b == cb);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                           = s;
+  typename S::reverse_iterator b        = s.rbegin();
+  if (!s.empty()) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.iterators/rend.pass.cpp

 // const_reverse_iterator rend() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s)
-{
-    const S& cs = s;
-    typename S::reverse_iterator e = s.rend();
-    typename S::const_reverse_iterator ce = cs.rend();
-    if (s.empty())
-    {
-        assert(e == s.rbegin());
-        assert(ce == cs.rbegin());
-    }
-    assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
-    assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs                           = s;
+  typename S::reverse_iterator e        = s.rend();
+  if (s.empty()) {
 }
 
-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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.modifiers/robust_against_adl.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
 struct Incomplete;
 template<class T> struct Holder { T t; };
 
 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);
+  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>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+#endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
-{
-    if (pos <= sv.size())
-    {
-        s.append(sv, pos, n);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected) {
+  if (pos <= sv.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(sv, pos, n);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test_npos(S s, SV sv, typename S::size_type pos, S expected)
-{
-    if (pos <= sv.size())
-    {
-        s.append(sv, pos);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test_npos(S s, SV sv, typename S::size_type pos, S expected) {
+  if (pos <= sv.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(sv, pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > sv.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   typedef std::string_view SV;
   test(S(), SV(), 0, 0, S());
   test(S(), SV(), 1, 0, S());
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), SV("12345"), 1, 3, S("12345678901234567890234"));
   test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
         S("123456789012345678906789012345"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   {
     typedef std::string S;
     typedef std::string_view SV;
     test_npos(S(), SV(), 0, S());
     test_npos(S(), SV(), 1, S());
     test_npos(S(), SV("12345"), 0, S("12345"));
#endif
 
     sv = s;
     s.append(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
   }
   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_append/initializer_list.pass.cpp

 
 // basic_string& append(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    std::string s("123");
-    s.append({'a', 'b', 'c'});
-    assert(s == "123abc");
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    S s("123");
-    s.append({'a', 'b', 'c'});
-    assert(s == "123abc");
-  }
+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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+#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.modifiers/string_append/iterator.pass.cpp

 //   basic_string& append(InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class It>
-TEST_CONSTEXPR_CXX20 void
-test(S s, It first, It last, S expected)
-{
-    s.append(first, last);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, It first, It last, S expected) {
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-struct Widget { operator char() const { throw 42; } };
+struct Widget {
+  operator char() const { throw 42; }
+};
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, It first, It last)
 {
     S original = s;
     typename S::iterator begin = s.begin();
     typename S::iterator end = s.end();
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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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";
#endif
     const uint8_t p[] = "ABCD";
 
     S s;
     s.append(p, p + 4);
     assert(s == "ABCD");
   }
 
   { // regression-test appending to self in sneaky ways
-    std::string s_short = "hello";
-    std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
-    std::string s_othertype = "hello";
-    std::string s_sneaky = "hello";
-
-    test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
-         std::string("hello\0", 6));
-    test(s_long, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
-         std::string("Lorem ipsum dolor sit amet, consectetur/\0", 41));
+    typedef std::string S;
+    S s_short     = "hello";
+    S s_long      = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_othertype = "hello";
+    S s_sneaky    = "hello";
+
+    test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1, S("hello\0", 6));
+    test(s_long,
+         s_long.data() + s_long.size(),
+         s_long.data() + s_long.size() + 1,
+         S("Lorem ipsum dolor sit amet, consectetur/\0", 41));
 
     s_sneaky.reserve(12);
-    test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, std::string("hellohello\0", 11));
+    test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, S("hellohello\0", 11));
 
-     if (!TEST_IS_CONSTANT_EVALUATED) {
-       const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
-       test(s_othertype, first + 2, first + 5, std::string("hellollo"));
-     }
+      const unsigned char* first = reinterpret_cast<const unsigned char*>(s_othertype.data());
+      test(s_othertype, first + 2, first + 5, S("hellollo"));
   }
 
   { // test with a move iterator that returns char&&
+    typedef std::string S;
     typedef forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
-    std::string s;
+    S s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
   { // test with a move iterator that returns char&&
+    typedef std::string S;
     typedef const char* It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
-    std::string s;
+    S s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
 
   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_append/pointer.pass.cpp

 // basic_string<charT,traits,Allocator>& append(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, const typename S::value_type* str, S expected)
-{
-    s.append(str);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, const typename S::value_type* str, S expected) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "", S());
   test(S(), "12345", S("12345"));
   test(S(), "12345678901234567890", S("12345678901234567890"));
 
   test(S("12345"), "", S("12345"));
   test(S("12345"), "12345", S("1234512345"));
   test(S("12345"), "1234567890", S("123451234567890"));
 
   test(S("12345678901234567890"), "", S("12345678901234567890"));
   test(S("12345678901234567890"), "12345", S("1234567890123456789012345"));
   test(S("12345678901234567890"), "12345678901234567890",
         S("1234567890123456789012345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   { // test appending to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.append(s_short.c_str());
     assert(s_short == "123/123/");
     s_short.append(s_short.c_str());
     assert(s_short == "123/123/123/123/");
     s_short.append(s_short.c_str());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.append(s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //   append(const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
-{
-    s.append(str, n);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, const typename S::value_type* str, typename S::size_type n, S expected) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "", 0, S());
   test(S(), "12345", 3, S("123"));
   test(S(), "12345", 4, S("1234"));
   test(S(), "12345678901234567890", 0, S());
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), "12345", 5, S("1234567890123456789012345"));
   test(S("12345678901234567890"), "12345678901234567890", 20,
         S("1234567890123456789012345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   { // test appending to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.append(s_short.data(), s_short.size());
     assert(s_short == "123/123/");
     s_short.append(s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/");
     s_short.append(s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.append(s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   return true;
 }
 
-int main(int, char**)
-{
+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

 
 // void push_back(charT c) // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
-struct veryLarge
-{
+struct veryLarge {
   long long a;
   char b;
 };
 
 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 void test(S s, typename S::value_type c, 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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);
   }
 
   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_append/size_char.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   append(size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, typename S::size_type n, typename S::value_type c, S expected)
-{
-    s.append(n, c);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type n, typename S::value_type c, S expected) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0, 'a', S());
   test(S(), 1, 'a', S(1, 'a'));
   test(S(), 10, 'a', S(10, 'a'));
   test(S(), 100, 'a', S(100, 'a'));
 
   test(S("12345"), 0, 'a', S("12345"));
   test(S("12345"), 1, 'a', S("12345a"));
   test(S("12345"), 10, 'a', S("12345aaaaaaaaaa"));
 
   test(S("12345678901234567890"), 0, 'a', S("12345678901234567890"));
   test(S("12345678901234567890"), 1, 'a', S("12345678901234567890a"));
   test(S("12345678901234567890"), 10, 'a', S("12345678901234567890aaaaaaaaaa"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.modifiers/string_append/string.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   append(const basic_string<charT,traits>& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, S str, S expected)
-{
-    s.append(str);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, S str, S expected) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), S(), S());
   test(S(), S("12345"), S("12345"));
   test(S(), S("1234567890"), S("1234567890"));
   test(S(), S("12345678901234567890"), S("12345678901234567890"));
TEST_CONSTEXPR_CXX20 void test_string() {
   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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
 #if TEST_STD_VER >= 11
   {   // LWG 2946
     std::string s;
     s.append({"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");
   }
 #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.modifiers/string_append/string_size_size.pass.cpp

 //  the "= npos" was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
-{
-    if (pos <= str.size())
-    {
-        s.append(str, pos, n);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected) {
+  if (pos <= str.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(str, pos, n);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S>
-TEST_CONSTEXPR_CXX20 void
-test_npos(S s, S str, typename S::size_type pos, S expected)
-{
-    if (pos <= str.size())
-    {
-        s.append(str, pos);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test_npos(S s, S str, typename S::size_type pos, S expected) {
+  if (pos <= str.size()) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
-    {
-        try
-        {
-            s.append(str, pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
-    }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), S(), 0, 0, S());
   test(S(), S(), 1, 0, S());
   test(S(), S("12345"), 0, 3, S("123"));
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), S("12345"), 1, 3, S("12345678901234567890234"));
   test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
         S("123456789012345678906789012345"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   {
     typedef std::string S;
     test_npos(S(), S(), 0, S());
     test_npos(S(), S(), 1, S());
     test_npos(S(), S("12345"), 0, S("12345"));
     test_npos(S(), S("12345"), 1, S("2345"));
     test_npos(S(), S("12345"), 3, S("45"));
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
   }
 
   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_append/string_view.pass.cpp

 //   append(basic_string_view<charT,traits> sv); // constexpr since C++20
 
 #include <string>
 #include <string_view>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
-TEST_CONSTEXPR_CXX20 void
-test(S s, SV sv, S expected)
-{
-    s.append(sv);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+TEST_CONSTEXPR_CXX20 void test(S s, SV sv, S expected) {
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   typedef std::string_view SV;
   test(S(), SV(), S());
   test(S(), SV("12345"), S("12345"));
   test(S(), SV("1234567890"), S("1234567890"));
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), SV("1234567890"), S("123456789012345678901234567890"));
   test(S("12345678901234567890"), SV("12345678901234567890"),
         S("1234567890123456789012345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #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.modifiers/string_assign/T_size_size.pass.cpp

 //    basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos, n);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), SV("12345"), 1, 3, S("234"));
   test(S("12345678901234567890"), SV("12345678901234567890"), 5, 10,
         S("6789012345"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   {
     typedef std::string S;
     typedef std::string_view SV;
     test_npos(S(), SV(), 0, S());
     test_npos(S(), SV(), 1, S());
     test_npos(S(), SV("12345"), 0, S("12345"));

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"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   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"
+#include "test_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(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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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 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**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
     return 0;
 }

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

 // basic_string<charT,traits,Allocator>& assign(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.assign(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), "12345", S("12345"));
   test(S("12345678901234567890"), "12345678901234567890",
         S("12345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   { // test assignment to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.assign(s_short.c_str());

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

 //   assign(const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.assign(str, n);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), "12345", 5, S("12345"));
   test(S("12345678901234567890"), "12345678901234567890", 20,
         S("12345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   { // test assign to self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.assign(s_short.data(), s_short.size());
     assert(s_short == "123/");
     s_short.assign(s_short.data() + 2, s_short.size() - 2);
     assert(s_short == "3/");
 
     s_long.assign(s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
     s_long.assign(s_long.data() + 2, 8 );
     assert(s_long == "rem ipsu");
   }
+
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //   assign(basic_string<charT,traits>&& str); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.assign(std::move(str));
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
   test(S("12345678901234567890"), S("12345678901234567890"),
         S("12345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 // basic_string<charT,traits,Allocator>&
 //   assign(size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.assign(n, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), 0, 'a', S());
   test(S("12345678901234567890"), 1, 'a', S(1, 'a'));
   test(S("12345678901234567890"), 10, 'a', S(10, 'a'));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 testAlloc(S s, S str, const typename S::allocator_type& a)
 {
     s.assign(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == str);
     assert(s.get_allocator() == a);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  {
-    typedef std::string S;
-    test(S(), S(), S());
-    test(S(), S("12345"), S("12345"));
-    test(S(), S("1234567890"), S("1234567890"));
-    test(S(), S("12345678901234567890"), S("12345678901234567890"));
+template <class 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("12345"), S(), S());
-    test(S("12345"), S("12345"), S("12345"));
-    test(S("12345"), S("1234567890"), S("1234567890"));
-    test(S("12345"), S("12345678901234567890"), S("12345678901234567890"));
 
-    test(S("1234567890"), S(), S());
-    test(S("1234567890"), S("12345"), S("12345"));
-    test(S("1234567890"), S("1234567890"), S("1234567890"));
-    test(S("1234567890"), S("12345678901234567890"), S("12345678901234567890"));
 
-    test(S("12345678901234567890"), S(), S());
-    test(S("12345678901234567890"), S("12345"), S("12345"));
-    test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
-    test(S("12345678901234567890"), S("12345678901234567890"),
-         S("12345678901234567890"));
+  test(S("12345678901234567890"), S("12345678901234567890"), S("12345678901234567890"));
 
-    testAlloc(S(), S(), std::allocator<char>());
-    testAlloc(S(), S("12345"), std::allocator<char>());
-    testAlloc(S(), S("1234567890"), std::allocator<char>());
-    testAlloc(S(), S("12345678901234567890"), std::allocator<char>());
-  }
+  testAlloc(S(), S(), Alloc<CharT>());
+  testAlloc(S(), S("12345"), Alloc<CharT>());
+  testAlloc(S(), S("1234567890"), Alloc<CharT>());
+  testAlloc(S(), S("12345678901234567890"), Alloc<CharT>());
 
-  { //  LWG#5579 make sure assign takes the allocators where appropriate
-    typedef other_allocator<char> A;  // has POCCA --> true
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    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));
-  }
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, other_allocator>() {
+  //  LWG#5579 make sure assign takes the allocators where appropriate
+  using A = other_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, other_allocator>(); // has POCCA --> true
 #if TEST_STD_VER >= 11
-  {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), S(), S());
-    test(S(), S("12345"), S("12345"));
-    test(S(), S("1234567890"), S("1234567890"));
-    test(S(), S("12345678901234567890"), S("12345678901234567890"));
-
-    test(S("12345"), S(), S());
-    test(S("12345"), S("12345"), S("12345"));
-    test(S("12345"), S("1234567890"), S("1234567890"));
-    test(S("12345"), S("12345678901234567890"), S("12345678901234567890"));
-
-    test(S("1234567890"), S(), S());
-    test(S("1234567890"), S("12345"), S("12345"));
-    test(S("1234567890"), S("1234567890"), S("1234567890"));
-    test(S("1234567890"), S("12345678901234567890"), S("12345678901234567890"));
-
-    test(S("12345678901234567890"), S(), S());
-    test(S("12345678901234567890"), S("12345"), S("12345"));
-    test(S("12345678901234567890"), S("1234567890"), S("1234567890"));
-    test(S("12345678901234567890"), S("12345678901234567890"),
-         S("12345678901234567890"));
-
-    testAlloc(S(), S(), min_allocator<char>());
-    testAlloc(S(), S("12345"), min_allocator<char>());
-    testAlloc(S(), S("1234567890"), min_allocator<char>());
-    testAlloc(S(), S("12345678901234567890"), min_allocator<char>());
-  }
+  test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_allocator>();
 #endif
 #if TEST_STD_VER > 14
   {
     typedef std::string S;
     static_assert(noexcept(S().assign(S())), "");  // LWG#2063
   }
 #endif
 

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

 // the =npos was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
     {
         s.assign(str, pos, n);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), S("12345"), 1, 3, S("234"));
   test(S("12345678901234567890"), S("12345678901234567890"), 5, 10,
         S("6789012345"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   {
     typedef std::string S;
     test_npos(S(), S(), 0, S());
     test_npos(S(), S(), 1, S());
     test_npos(S(), S("12345"), 0, S("12345"));
     test_npos(S(), S("12345"), 1, S("2345"));
     test_npos(S(), S("12345"), 3, S("45"));
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
   }
-
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test_string() {
   testAlloc(S(), SV("12345"), A());
   testAlloc(S(), SV("1234567890"), A());
   testAlloc(S(), SV("12345678901234567890"), A());
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S str, typename S::value_type* s, typename S::size_type n,
      typename S::size_type pos)
 {
     const S& cs = str;
     if (pos <= cs.size())
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), s, 20, 0);
   test(S("abcdefghijklmnopqrst"), s, 20, 1);
   test(S("abcdefghijklmnopqrst"), s, 21, 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>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
-
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp

 
 // iterator erase(const_iterator p); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, S expected)
 {
     typename S::const_iterator p = s.begin() + pos;
     typename S::iterator i = s.erase(p);
     LIBCPP_ASSERT(s.__invariants());
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), 1, S("acdefghijklmnopqrst"));
   test(S("abcdefghijklmnopqrst"), 10, S("abcdefghijlmnopqrst"));
   test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp

 
 // iterator erase(const_iterator first, const_iterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, typename S::difference_type n, S expected)
 {
     typename S::const_iterator first = s.cbegin() + pos;
     typename S::const_iterator last = s.cbegin() + pos + n;
     typename S::iterator i = s.erase(first, last);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"));
   test(S("abcdefghijklmnopqrst"), 19, 1, S("abcdefghijklmnopqrs"));
   test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
-
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp

 
 // void pop_back(); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S expected)
 {
     s.pop_back();
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcde"), S("abcd"));
   test(S("abcdefghij"), S("abcdefghi"));
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp

 //   erase(size_type pos = 0, size_type n = npos); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcde"), S(""));
   test(S("abcdefghij"), S(""));
   test(S("abcdefghijklmnopqrst"), S(""));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 // iterator insert(const_iterator p, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S& s, typename S::const_iterator p, typename S::value_type c, S expected)
 {
     bool sufficient_cap = s.size() < s.capacity();
     typename S::difference_type pos = p - s.begin();
     typename S::iterator i = s.insert(p, c);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(s, s.begin()+4, 'A', S("a567A1432dcb"));
   test(s, s.begin()+5, 'B', S("a567AB1432dcb"));
   test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_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"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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_insert/iter_iter_iter.pass.cpp

 //   iterator insert(const_iterator p, InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, It first, It last, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, first, last);
     LIBCPP_ASSERT(s.__invariants());
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
   test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
         S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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";

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

 
 // iterator insert(const_iterator p, size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, typename S::size_type n,
      typename S::value_type c, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, n, c);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), 20, 5, '1', S("abcdefghijklmnopqrst11111"));
   test(S("abcdefghijklmnopqrst"), 20, 10, '1', S("abcdefghijklmnopqrst1111111111"));
   test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     const typename S::size_type old_size = s.size();
#if TEST_STD_VER > 17
   static_assert(test31<S, SV>());
 #endif
 }
 
 int main(int, char**)
 {
   test<std::string, std::string_view>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>,
-       std::basic_string_view<char, std::char_traits<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> >,
+       std::basic_string_view<char, std::char_traits<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> >,
+       std::basic_string_view<char, std::char_traits<char> > >();
 #endif
 
   return 0;
 }

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

 //   insert(size_type pos, const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), 21, "12345", S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, "1234567890", S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", S("can't happen"));
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   { // test inserting into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(0, s_short.c_str());

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

 //   insert(size_type pos, const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
TEST_CONSTEXPR_CXX20 bool test() {
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 9, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "1234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 19, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 20, S("can't happen"));
   }
-
   { // test inserting into self
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(0, s_short.data(), s_short.size());
     assert(s_short == "123/123/");
     s_short.insert(0, s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/");
     s_short.insert(0, s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.insert(0, s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   return true;
 }
 
 int main(int, char**)
 {
   test<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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
 #if TEST_STD_VER > 17
   static_assert(test<std::string>());
-  static_assert(test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>());
+  static_assert(test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >());
+  static_assert(test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >());
 #endif
 
   return 0;
 }

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

 //   insert(size_type pos, size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n,
      typename S::value_type str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), 21, 5, '1', S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, 10, '1', S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, 20, '1', S("can't happen"));
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 //   insert(size_type pos1, const basic_string& str); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), 21, S("12345"), S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), S("can't happen"));
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
 #if TEST_STD_VER >= 11
   {   // LWG 2946
     std::string s;
     s.insert(0, {"abc", 1});
     assert(s.size() == 1);
     assert(s == "a");

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

 // the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
#if TEST_STD_VER > 17
   static_assert(test30<S>());
 #endif
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 //   insert(size_type pos, string_view sv); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), 21, SV("12345"), S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
   test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
 }
 
 TEST_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   { // test inserting into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(0, s_short.c_str());

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

 
 // basic_string<charT,traits,Allocator>& operator+=(charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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/pointer.pass.cpp

 
 // basic_string<charT,traits,Allocator>& operator+=(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890"), "1234567890", S("123456789012345678901234567890"));
   test(S("12345678901234567890"), "12345678901234567890",
         S("1234567890123456789012345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 // basic_string<charT,traits,Allocator>&
 //   operator+=(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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_iter_iter.pass.cpp

 
 #include <string>
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_iterators.h"
+#include "test_allocator.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
#if TEST_STD_VER > 17
   static_assert(test9<S>());
 #endif
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
-}
+}
 No newline at end of file

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

 #include <stdio.h>
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, const typename S::value_type* str, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+#endif
 
   return 0;
 }

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

 //   replace(const_iterator i1, const_iterator i2, const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, const typename S::value_type* str,
      typename S::size_type n2, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
#if TEST_STD_VER > 17
   static_assert(test9<S>());
 #endif
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
-}
+}
 No newline at end of file

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

 //   replace(const_iterator i1, const_iterator i2, size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, typename S::size_type n2,
      typename S::value_type c, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghijklmnopqrst"), 19, 1, 10, '3', S("abcdefghijklmnopqrs3333333333"));
     test(S("abcdefghijklmnopqrst"), 19, 1, 20, '3', S("abcdefghijklmnopqrs33333333333333333333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 0, '3', S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 5, '3', S("abcdefghijklmnopqrst33333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 10, '3', S("abcdefghijklmnopqrst3333333333"));
     test(S("abcdefghijklmnopqrst"), 20, 0, 20, '3', S("abcdefghijklmnopqrst33333333333333333333"));
 }
 
-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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
-}
+}
 No newline at end of file

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

 //   replace(const_iterator i1, const_iterator i2, const basic_string& str); // constexpr since C++20
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
#if TEST_STD_VER >= 11
   }
 #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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 //   replace(const_iterator i1, const_iterator i2, basic_string_view<charT,traits> sv); // constexpr since C++20
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
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>();
-#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>();
+  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
-  }
-#endif
-}
 
 int main(int, char**)
 {
-  test();
+  test<char, std::allocator>();
+#if TEST_STD_VER >= 11
+  test<char, min_allocator>();
+  test<char, fancy_pointer_allocator>();
+#endif
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     typedef typename S::size_type SizeT;
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>();
+  test<char, fancy_pointer_allocator>();
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;

 #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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
#if TEST_STD_VER > 17
   static_assert(test11<S>());
 #endif
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      typename S::size_type n2, typename S::value_type c,
      S expected)
 {
     const typename S::size_type old_size = s.size();
#if TEST_STD_VER > 17
   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>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
#if TEST_STD_VER >= 11
   }
 #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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      S str, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
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(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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
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>();
+  test<char, fancy_pointer_allocator>();
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s1_ = s1;
     S s2_ = s2;
     s1.swap(s2);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), S("12345"));
   test(S("abcdefghijklmnopqrst"), S("1234567890"));
   test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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.cmp/comparison.pass.cpp

for (size_t j = 0; j < v.size(); ++j) {
       // NUL test omitted for c-strings since it will fail.
       assert(testOrder(vn[i], vn[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
     }
   }
 }
 
 constexpr bool test_all_types() {
   test<std::string>();
-  test<std::basic_string<char, constexpr_char_traits<char>>, std::weak_ordering>();
+  test<std::basic_string<char, constexpr_char_traits<char> >, std::weak_ordering>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<std::wstring>();
-  test<std::basic_string<wchar_t, constexpr_char_traits<wchar_t>>, std::weak_ordering>();
+  test<std::basic_string<wchar_t, constexpr_char_traits<wchar_t> >, std::weak_ordering>();
 #endif
   test<std::u8string>();
-  test<std::basic_string<char8_t, constexpr_char_traits<char8_t>>, std::weak_ordering>();
+  test<std::basic_string<char8_t, constexpr_char_traits<char8_t> >, std::weak_ordering>();
   test<std::u16string>();
-  test<std::basic_string<char16_t, constexpr_char_traits<char16_t>>, std::weak_ordering>();
+  test<std::basic_string<char16_t, constexpr_char_traits<char16_t> >, std::weak_ordering>();
   test<std::u32string>();
-  test<std::basic_string<char32_t, constexpr_char_traits<char32_t>>, std::weak_ordering>();
+  test<std::basic_string<char32_t, constexpr_char_traits<char32_t> >, std::weak_ordering>();
 
   return true;
 }
 
 int main(int, char**) {
   test_all_types();
   static_assert(test_all_types());
 
   return 0;
 }

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

 //           basic_string<charT,traits,Allocator>& str);
 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "test_macros.h"
+#include "test_allocator.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> >;
+  using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+    S s("initial text");
 #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");
-    }
+    WS s(L"initial text");
 #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
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::wistringstream in(L" abc\n  def\n   ghij");
-        S s(L"initial text");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == L" abc");
-        std::getline(in, s);
-        assert(in.good());
-        assert(s == L"  def");
-        std::getline(in, s);
-        assert(in.eof());
-        assert(s == L"   ghij");
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
-#endif // TEST_STD_VER >= 11
+
+int main(int, char**) {
+  test_string<std::allocator>();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator>();
+  test_string<fancy_pointer_allocator>();
+#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;
         bool threw = false;
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
         assert(!is.bad());
         assert( is.fail());
         assert( is.eof());
         assert(threw);
         assert(s == L"");
     }
 #endif
 #endif // TEST_HAS_NO_EXCEPTIONS
-
-    return 0;
 }

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

 //           basic_string<charT,traits,Allocator>& str, charT delim);
 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "test_macros.h"
+#include "test_allocator.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> >;
+  using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+    S s("initial text");
 #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");
-    }
+    WS s(L"initial text");
 #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
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::wistringstream in(L" abc*  def**   ghij");
-        S s(L"initial text");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L" abc");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L"  def");
-        std::getline(in, s, L'*');
-        assert(in.good());
-        assert(s == L"");
-        std::getline(in, s, L'*');
-        assert(in.eof());
-        assert(s == L"   ghij");
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
-#endif // TEST_STD_VER >= 11
+
+int main(int, char**) {
+  test_string<std::allocator>();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator>();
+  test_string<fancy_pointer_allocator>();
+#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;
         bool threw = false;
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
         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
-
-    return 0;
 }

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

 //           basic_string<charT,traits,Allocator>& str, charT delim);
 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
-int main(int, char**)
+template <template <class> class Alloc>
+void test() {
   {
-    {
-        std::string s("initial text");
-        std::getline(std::istringstream(" abc*  def*   ghij"), s, '*');
-        assert(s == " abc");
-    }
+    using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+    S s("initial text");
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
-        std::wstring s(L"initial text");
-        std::getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
-        assert(s == L" abc");
+      using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+      WS s(L"initial text");
     }
 #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>();
+  test<fancy_pointer_allocator>();
 #endif
 
   return 0;
 }

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

 //           basic_string<charT,traits,Allocator>& str);
 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
-int main(int, char**)
+template <template <class> class Alloc>
+void test() {
   {
-    {
-        std::string s("initial text");
-        std::getline(std::istringstream(" abc\n  def\n   ghij"), s);
-        assert(s == " abc");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wstring s(L"initial text");
-        std::getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
-        assert(s == L" abc");
-    }
-#endif
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
-        S s("initial text");
-        std::getline(std::istringstream(" abc\n  def\n   ghij"), s);
-        assert(s == " abc");
-    }
+    using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t> > S;
-        S s(L"initial text");
-        std::getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
-        assert(s == L" abc");
+      using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+      WS s(L"initial text");
     }
 #endif
+}
+
+int main(int, char**) {
+  test<std::allocator>();
+  test<min_allocator>();
+
+#if TEST_STD_VER >= 11
+  test<fancy_pointer_allocator>();
+#endif // TEST_STD_VER >= 11
 
   return 0;
 }

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

 //              basic_string<charT,traits,Allocator>& str);
 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "test_macros.h"
+#include "test_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream in("a bc defghij");
-        std::string s("initial text");
-        in >> s;
-        assert(in.good());
-        assert(s == "a");
-        assert(in.peek() == ' ');
-        in >> s;
-        assert(in.good());
-        assert(s == "bc");
-        assert(in.peek() == ' ');
-        in.width(3);
-        in >> s;
-        assert(in.good());
-        assert(s == "def");
-        assert(in.peek() == 'g');
-        in >> s;
-        assert(in.eof());
-        assert(s == "ghij");
-        in >> s;
-        assert(in.fail());
-    }
+template <template <class> class Alloc>
+void test_string() {
+  using S  = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
+  using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+    S s("initial text");
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         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
+}
+
+int main(int, char**) {
+  test_string<std::allocator>();
+#if TEST_STD_VER >= 11
+  test_string<min_allocator>();
+  test_string<fancy_pointer_allocator>();
+#endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::stringbuf sb;
         std::istream is(&sb);
         is.exceptions(std::ios::failbit);
 
         bool threw = false;
         try {
#ifndef TEST_HAS_NO_EXCEPTIONS
         }
 
         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
 
     return 0;
 }

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

 //              const basic_string<charT,traits,Allocator>& str);
 
 #include <string>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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;
-        S s("some text");
-        out << s;
-        assert(out.good());
-        assert(s == out.str());
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
-        S s("some text");
-        out.width(12);
-        out << s;
-        assert(out.good());
-        assert("   " + s == out.str());
-    }
+    OS out;
+    OS out;
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
-        S s(L"some text");
-        out << s;
-        assert(out.good());
-        assert(s == out.str());
-    }
+  using WS  = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+  using WOS = std::basic_ostringstream<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
+    WOS out;
+    WS s(L"some text");
     {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        std::basic_ostringstream<S::value_type, S::traits_type, S::allocator_type> out;
-        S s(L"some text");
-        out.width(12);
-        out << s;
-        assert(out.good());
-        assert(L"   " + s == out.str());
+      WOS out;
+      WS s(L"some text");
     }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
+#endif
+}
+
+int main(int, char**) {
+  test<std::allocator>();
+
+#if TEST_STD_VER >= 11
+  test<min_allocator>();
+  test<fancy_pointer_allocator>();
 #endif // TEST_STD_VER >= 11
 
   return 0;
 }

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

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s1_ = s1;
     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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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.special/swap_noexcept.pass.cpp

 int main(int, char**)
 {
     {
         typedef std::string C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #if defined(_LIBCPP_VERSION)
     {
-        typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
-        static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
+      typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > C;
     }
 #endif // _LIBCPP_VERSION
     {
-        typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
+      typedef std::basic_string<char, std::char_traits<char>, some_alloc<char> > C;
 #if TEST_STD_VER >= 14
     //  In C++14, if POCS is set, swapping the allocator is required not to throw
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #else
         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #endif
     }
 #if TEST_STD_VER >= 14
     {
-        typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
+      typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char> > C;
       //  if the allocators are always equal, then the swap can be noexcept
-        static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
+      static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
 
   return 0;
 }

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

 // template<class charT, class traits, class Allocator>
 //   bool operator!=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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 void test_string() {
   test("abcdefghijklmnopqrst", S("abcde"), true);
   test("abcdefghijklmnopqrst", S("abcdefghij"), true);
   test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 // template<class charT, class traits, class Allocator>
 //   bool operator!=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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 void test_string() {
   test(S("abcdefghijklmnopqrst"), "abcde", true);
   test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
   test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
 //                   const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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 void test_string() {
   test(S("abcdefghijklmnopqrst"), S("abcde"), true);
   test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
-  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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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 void test_string() {
   test(S("abcdefghijklmnopqrst"), SV("abcde"), true);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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 void test_string() {
   test(SV("abcdefghijklmnopqrst"), S("abcde"), true);
   test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
   test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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+/allocator_propagation.pass.cpp

public:
 
   typedef std::true_type propagate_on_container_copy_assignment;
   typedef std::true_type propagate_on_container_move_assignment;
   typedef std::true_type propagate_on_container_swap;
 };
 
 template <class CharT>
 TEST_CONSTEXPR_CXX20 bool test() {
-  using S = std::basic_string<CharT, std::char_traits<CharT>, soccc_allocator<CharT>>;
+  using S = std::basic_string<CharT, std::char_traits<CharT>, soccc_allocator<CharT> >;
   {
     int soccc_lhs = 0;
     int soccc_rhs = 0;
     S lhs(soccc_allocator<CharT>{&soccc_lhs});
     S rhs(soccc_allocator<CharT>{&soccc_rhs});
     auto r = lhs + rhs;
     assert(r.get_allocator().get_soccc() == &soccc_lhs);
     assert(r.get_allocator().get_self_soccc() == 1);

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

 //   operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(typename S::value_type lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   operator+(const charT* lhs, basic_string<charT,traits,Allocator>&& rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(const typename S::value_type* lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #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() {
+  test0("abcdefghij", S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test0("abcdefghijklmnopqrst", S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test0("abcdefghijklmnopqrst", S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1("", S(""), S(""));
-    test1("", S("12345"), S("12345"));
-    test1("", S("1234567890"), S("1234567890"));
-    test1("", S("12345678901234567890"), S("12345678901234567890"));
-    test1("abcde", S(""), S("abcde"));
-    test1("abcde", S("12345"), S("abcde12345"));
-    test1("abcde", S("1234567890"), S("abcde1234567890"));
-    test1("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
-    test1("abcdefghij", S(""), S("abcdefghij"));
-    test1("abcdefghij", S("12345"), S("abcdefghij12345"));
-    test1("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
-    test1("abcdefghij", S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test1("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
-    test1("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
-    test1("abcdefghijklmnopqrst", S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test1("abcdefghijklmnopqrst", S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
-    test0("", S(""), S(""));
-    test0("", S("12345"), S("12345"));
-    test0("", S("1234567890"), S("1234567890"));
-    test0("", S("12345678901234567890"), S("12345678901234567890"));
-    test0("abcde", S(""), S("abcde"));
-    test0("abcde", S("12345"), S("abcde12345"));
-    test0("abcde", S("1234567890"), S("abcde1234567890"));
-    test0("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
-    test0("abcdefghij", S(""), S("abcdefghij"));
-    test0("abcdefghij", S("12345"), S("abcdefghij12345"));
-    test0("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
-    test0("abcdefghij", S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test0("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
-    test0("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
-    test0("abcdefghijklmnopqrst", S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test0("abcdefghijklmnopqrst", S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
+  test1("abcdefghij", S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test1("abcdefghijklmnopqrst", S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test1("abcdefghijklmnopqrst", S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+#endif
 
-    test1("", S(""), S(""));
-    test1("", S("12345"), S("12345"));
-    test1("", S("1234567890"), S("1234567890"));
-    test1("", S("12345678901234567890"), S("12345678901234567890"));
-    test1("abcde", S(""), S("abcde"));
-    test1("abcde", S("12345"), S("abcde12345"));
-    test1("abcde", S("1234567890"), S("abcde1234567890"));
-    test1("abcde", S("12345678901234567890"), S("abcde12345678901234567890"));
-    test1("abcdefghij", S(""), S("abcdefghij"));
-    test1("abcdefghij", S("12345"), S("abcdefghij12345"));
-    test1("abcdefghij", S("1234567890"), S("abcdefghij1234567890"));
-    test1("abcdefghij", S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test1("abcdefghijklmnopqrst", S(""), S("abcdefghijklmnopqrst"));
-    test1("abcdefghijklmnopqrst", S("12345"), S("abcdefghijklmnopqrst12345"));
-    test1("abcdefghijklmnopqrst", S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test1("abcdefghijklmnopqrst", S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(const S& lhs, typename S::value_type rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   operator+(basic_string<charT,traits,Allocator>&& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const typename S::value_type* rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #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() {
+  test0(S("abcdefghij"), "12345678901234567890", S("abcdefghij12345678901234567890"));
+  test0(S("abcdefghijklmnopqrst"), "1234567890", S("abcdefghijklmnopqrst1234567890"));
+  test0(S("abcdefghijklmnopqrst"), "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1(S(""), "", S(""));
-    test1(S(""), "12345", S("12345"));
-    test1(S(""), "1234567890", S("1234567890"));
-    test1(S(""), "12345678901234567890", S("12345678901234567890"));
-    test1(S("abcde"), "", S("abcde"));
-    test1(S("abcde"), "12345", S("abcde12345"));
-    test1(S("abcde"), "1234567890", S("abcde1234567890"));
-    test1(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
-    test1(S("abcdefghij"), "", S("abcdefghij"));
-    test1(S("abcdefghij"), "12345", S("abcdefghij12345"));
-    test1(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
-    test1(S("abcdefghij"), "12345678901234567890",
-          S("abcdefghij12345678901234567890"));
-    test1(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
-    test1(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
-    test1(S("abcdefghijklmnopqrst"), "1234567890",
-          S("abcdefghijklmnopqrst1234567890"));
-    test1(S("abcdefghijklmnopqrst"), "12345678901234567890",
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
-  {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
-    test0(S(""), "", S(""));
-    test0(S(""), "12345", S("12345"));
-    test0(S(""), "1234567890", S("1234567890"));
-    test0(S(""), "12345678901234567890", S("12345678901234567890"));
-    test0(S("abcde"), "", S("abcde"));
-    test0(S("abcde"), "12345", S("abcde12345"));
-    test0(S("abcde"), "1234567890", S("abcde1234567890"));
-    test0(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
-    test0(S("abcdefghij"), "", S("abcdefghij"));
-    test0(S("abcdefghij"), "12345", S("abcdefghij12345"));
-    test0(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
-    test0(S("abcdefghij"), "12345678901234567890",
-          S("abcdefghij12345678901234567890"));
-    test0(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
-    test0(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
-    test0(S("abcdefghijklmnopqrst"), "1234567890",
-          S("abcdefghijklmnopqrst1234567890"));
-    test0(S("abcdefghijklmnopqrst"), "12345678901234567890",
-          S("abcdefghijklmnopqrst12345678901234567890"));
+  test1(S("abcdefghij"), "12345678901234567890", S("abcdefghij12345678901234567890"));
+  test1(S("abcdefghijklmnopqrst"), "1234567890", S("abcdefghijklmnopqrst1234567890"));
+  test1(S("abcdefghijklmnopqrst"), "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
+#endif
 
-    test1(S(""), "", S(""));
-    test1(S(""), "12345", S("12345"));
-    test1(S(""), "1234567890", S("1234567890"));
-    test1(S(""), "12345678901234567890", S("12345678901234567890"));
-    test1(S("abcde"), "", S("abcde"));
-    test1(S("abcde"), "12345", S("abcde12345"));
-    test1(S("abcde"), "1234567890", S("abcde1234567890"));
-    test1(S("abcde"), "12345678901234567890", S("abcde12345678901234567890"));
-    test1(S("abcdefghij"), "", S("abcdefghij"));
-    test1(S("abcdefghij"), "12345", S("abcdefghij12345"));
-    test1(S("abcdefghij"), "1234567890", S("abcdefghij1234567890"));
-    test1(S("abcdefghij"), "12345678901234567890",
-          S("abcdefghij12345678901234567890"));
-    test1(S("abcdefghijklmnopqrst"), "", S("abcdefghijklmnopqrst"));
-    test1(S("abcdefghijklmnopqrst"), "12345", S("abcdefghijklmnopqrst12345"));
-    test1(S("abcdefghijklmnopqrst"), "1234567890",
-          S("abcdefghijklmnopqrst1234567890"));
-    test1(S("abcdefghijklmnopqrst"), "12345678901234567890",
-          S("abcdefghijklmnopqrst12345678901234567890"));
-  }
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //             const basic_string<charT,traits,Allocator>&& rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const S& rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test2(const S& lhs, S&& rhs, const S& x) {
   assert(lhs + std::move(rhs) == x);
 }
 
 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() {
+  test0(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test0(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test0(S("abcdefghijklmnopqrst"), S("12345"), S("abcdefghijklmnopqrst12345"));
+  test0(S("abcdefghijklmnopqrst"), S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test0(S("abcdefghijklmnopqrst"), S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 #if TEST_STD_VER >= 11
-  {
-    typedef std::string S;
-    test1(S(""), S(""), S(""));
-    test1(S(""), S("12345"), S("12345"));
-    test1(S(""), S("1234567890"), S("1234567890"));
-    test1(S(""), S("12345678901234567890"), S("12345678901234567890"));
-    test1(S("abcde"), S(""), S("abcde"));
-    test1(S("abcde"), S("12345"), S("abcde12345"));
-    test1(S("abcde"), S("1234567890"), S("abcde1234567890"));
-    test1(S("abcde"), S("12345678901234567890"),
-          S("abcde12345678901234567890"));
-    test1(S("abcdefghij"), S(""), S("abcdefghij"));
-    test1(S("abcdefghij"), S("12345"), S("abcdefghij12345"));
-    test1(S("abcdefghij"), S("1234567890"), S("abcdefghij1234567890"));
-    test1(S("abcdefghij"), S("12345678901234567890"),
-          S("abcdefghij12345678901234567890"));
-    test1(S("abcdefghijklmnopqrst"), S(""), S("abcdefghijklmnopqrst"));
-    test1(S("abcdefghijklmnopqrst"), S("12345"),
-          S("abcdefghijklmnopqrst12345"));
-    test1(S("abcdefghijklmnopqrst"), S("1234567890"),
-          S("abcdefghijklmnopqrst1234567890"));
-    test1(S("abcdefghijklmnopqrst"), S("12345678901234567890"),
-          S("abcdefghijklmnopqrst12345678901234567890"));
+  test1(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test1(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  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"));
+  test2(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test2(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  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"));
+  test3(S("abcde"), S("12345678901234567890"), S("abcde12345678901234567890"));
+  test3(S("abcdefghij"), S("12345678901234567890"), S("abcdefghij12345678901234567890"));
+  test3(S("abcdefghijklmnopqrst"), S("12345"), S("abcdefghijklmnopqrst12345"));
+  test3(S("abcdefghijklmnopqrst"), S("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+  test3(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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator==(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   bool operator==(const basic_string<charT,traits,Allocator>& lhs,
 //                   const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator>(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator>(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   bool operator>(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator>=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator>=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator<(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator<(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   bool operator<(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator<=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 // template<class charT, class traits, class Allocator>
 //   bool operator<=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //   bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_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>();
+  test_string<char, fancy_pointer_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

 
 // const charT* c_str() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     typedef typename S::traits_type T;
     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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 // const charT* data() const; // constexpr since C++20
 //       charT* data();   // C++17, constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test_const(const S& s)
 {
     typedef typename S::traits_type T;
     const typename S::value_type* str = s.data();
     if (s.size() > 0)
test_nonconst(S& s)
     {
         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
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+#if TEST_STD_VER > 14
   {
-    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"));
+    S s1("");
+    test_nonconst(s1);
+    S s2("abcde");
+    test_nonconst(s2);
+    S s3("abcdefghij");
+    test_nonconst(s3);
+    S s4("abcdefghijklmnopqrst");
+    test_nonconst(s4);
   }
 #endif
-#if TEST_STD_VER > 14
-  {
-    typedef std::string S;
-    S s1("");                     test_nonconst(s1);
-    S s2("abcde");                test_nonconst(s2);
-    S s3("abcdefghij");           test_nonconst(s3);
-    S s4("abcdefghijklmnopqrst"); test_nonconst(s4);
-  }
+
+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>, fancy_pointer_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

 
 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 CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+  test(S(""), A());
+  test(S("abcde", A()), A());
+  test(S("abcdefghij", A()), A());
+  test(S("abcdefghijklmnopqrst", A()), A());
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+  using A = test_allocator<char>;
+  using S = std::basic_string<char, std::char_traits<char>, A>;
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(""), A());
-    test(S("abcde", A()), A());
-    test(S("abcdefghij", A()), A());
-    test(S("abcdefghijklmnopqrst", A()), A());
-  }
+  test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_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/pointer.pass.cpp

 
 // int compare(const charT *s) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
// calls compare(pos, n1, const char *, 0)
   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(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>();
+  test<char, fancy_pointer_allocator>();
 #endif
 
   return 0;
 }

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

 
 // int compare(size_type pos, size_type n1, const charT *s) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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_pointer_size.pass.cpp

 
 // int compare(size_type pos, size_type n1, const charT *s, size_type n2) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
#if TEST_STD_VER > 17
   static_assert(test11<S>());
 #endif
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
-  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 // int compare(size_type pos1, size_type n1, const basic_string& str) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
TEST_CONSTEXPR_CXX20 void test2()
     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);
 }
 
-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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_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_size_size.pass.cpp

 //             size_type pos2, size_type n2=npos) const; // constexpr since C++20
 //  the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
#if TEST_STD_VER > 17
   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> > >();
+  test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
 #endif
 
   return 0;
 }

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

 
 // int compare(size_type pos1, size_type n1, basic_string_view sv) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
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>();
+  test_string<char, fancy_pointer_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

 
 // int compare(const basic_string& str) const // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // int compare(const basic_string_view sv) const // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 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>();
+  test_string<char, fancy_pointer_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

 
 // size_type find_first_not_of(charT c, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c, pos));
     assert(s.find_first_not_of(c, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_not_of(const charT* s, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
     assert(s.find_first_not_of(str, pos) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos, n));
     assert(s.find_first_not_of(str, pos, n) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_not_of(const basic_string& str, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
     assert(s.find_first_not_of(str, pos) == x);
     if (x != S::npos)
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_not_of(basic_string_view sv, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(sv, pos));
     assert(s.find_first_not_of(sv, pos) == x);
     if (x != S::npos)
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>();
+  test_string<char, fancy_pointer_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

 
 // size_type find_first_of(charT c, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c, pos));
     assert(s.find_first_of(c, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x < s.size());
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_of(const charT* s, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
     assert(s.find_first_of(str, pos) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos, n));
     assert(s.find_first_of(str, pos, n) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_of(const basic_string& str, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
     assert(s.find_first_of(str, pos) == x);
     if (x != S::npos)
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_first_of(const basic_string_view sv, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(sv, pos));
     assert(s.find_first_of(sv, pos) == x);
     if (x != S::npos)
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>();
+  test_string<char, fancy_pointer_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

 
 // size_type find_last_not_of(charT c, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c, pos));
     assert(s.find_last_not_of(c, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_not_of(const charT* s, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
     assert(s.find_last_not_of(str, pos) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos, n));
     assert(s.find_last_not_of(str, pos, n) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_not_of(const basic_string& str, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
     assert(s.find_last_not_of(str, pos) == x);
     if (x != S::npos)
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_not_of(basic_string_view sv, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(sv, pos));
     assert(s.find_last_not_of(sv, pos) == x);
     if (x != S::npos)
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>();
+  test_string<char, fancy_pointer_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

 
 // size_type find_last_of(charT c, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c, pos));
     assert(s.find_last_of(c, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_of(const charT* s, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
     assert(s.find_last_of(str, pos) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos, n));
     assert(s.find_last_of(str, pos, n) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_of(const basic_string& str, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
     assert(s.find_last_of(str, pos) == x);
     if (x != S::npos)
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find_last_of(const basic_string_view sv, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(sv, pos));
     assert(s.find_last_of(sv, pos) == x);
     if (x != S::npos)
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>();
+  test_string<char, fancy_pointer_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

 
 // size_type find(charT c, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(c, pos));
     assert(s.find(c, pos) == x);
     if (x != S::npos)
         assert(pos <= x && x + 1 <= s.size());
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find(const charT* s, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
     assert(s.find(str, pos) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos, n));
     assert(s.find(str, pos, n) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find(const basic_string& str, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
     assert(s.find(str, pos) == x);
     if (x != S::npos)
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type find(basic_string_view sv, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(sv, pos));
     assert(s.find(sv, pos) == x);
     if (x != S::npos)
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>();
+  test_string<char, fancy_pointer_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

 
 // size_type rfind(charT c, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(c, pos));
     assert(s.rfind(c, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x + 1 <= s.size());
 }
 
 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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type rfind(const charT* s, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
     assert(s.rfind(str, pos) == x);
TEST_CONSTEXPR_CXX20 void test1()
     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>();
-  }
+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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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_size.pass.cpp

 
 // size_type rfind(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
       typename S::size_type n, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos, n));
     assert(s.rfind(str, pos, n) == x);
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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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

 
 // size_type rfind(const basic_string& str, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
     assert(s.rfind(str, pos) == x);
     if (x != S::npos)
TEST_CONSTEXPR_CXX20 void test1()
     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
+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> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.rfind({"abc", 1}) == std::string::npos);
   }
 #endif
 
   return true;
 }

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

 
 // size_type rfind(basic_string_view sv, size_type pos = npos) const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv, pos));
     assert(s.rfind(sv, pos) == x);
     if (x != S::npos)
TEST_CONSTEXPR_CXX20 void test1()
     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>();
-  }
+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>();
+  test_string<char, fancy_pointer_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_substr/substr.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n)
 {
     if (pos <= s.size())
     {
         S str = s.substr(pos, n);
else if (!TEST_IS_CONSTANT_EVALUATED)
         catch (std::out_of_range&)
         {
             assert(pos > s.size());
         }
     }
 #endif
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-    {
-    typedef std::string S;
-    test(S(""), 0, 0);
-    test(S(""), 1, 0);
-    test(S("pniot"), 0, 0);
-    test(S("htaob"), 0, 1);
-    test(S("fodgq"), 0, 2);
-    test(S("hpqia"), 0, 4);
-    test(S("qanej"), 0, 5);
-    test(S("dfkap"), 1, 0);
-    test(S("clbao"), 1, 1);
-    test(S("ihqrf"), 1, 2);
-    test(S("mekdn"), 1, 3);
-    test(S("ngtjf"), 1, 4);
-    test(S("srdfq"), 2, 0);
-    test(S("qkdrs"), 2, 1);
-    test(S("ikcrq"), 2, 2);
-    test(S("cdaih"), 2, 3);
-    test(S("dmajb"), 4, 0);
-    test(S("karth"), 4, 1);
-    test(S("lhcdo"), 5, 0);
-    test(S("acbsj"), 6, 0);
-    test(S("pbsjikaole"), 0, 0);
-    test(S("pcbahntsje"), 0, 1);
-    test(S("mprdjbeiak"), 0, 5);
-    test(S("fhepcrntko"), 0, 9);
-    test(S("eqmpaidtls"), 0, 10);
-    test(S("joidhalcmq"), 1, 0);
-    test(S("omigsphflj"), 1, 1);
-    test(S("kocgbphfji"), 1, 4);
-    test(S("onmjekafbi"), 1, 8);
-    test(S("fbslrjiqkm"), 1, 9);
-    test(S("oqmrjahnkg"), 5, 0);
-    test(S("jeidpcmalh"), 5, 1);
-    test(S("schfalibje"), 5, 2);
-    test(S("crliponbqe"), 5, 4);
-    test(S("igdscopqtm"), 5, 5);
-    test(S("qngpdkimlc"), 9, 0);
-    test(S("thdjgafrlb"), 9, 1);
-    test(S("hcjitbfapl"), 10, 0);
-    test(S("mgojkldsqh"), 11, 0);
-    test(S("gfshlcmdjreqipbontak"), 0, 0);
-    test(S("nadkhpfemgclosibtjrq"), 0, 1);
-    test(S("nkodajteqplrbifhmcgs"), 0, 10);
-    test(S("ofdrqmkeblthacpgijsn"), 0, 19);
-    test(S("gbmetiprqdoasckjfhln"), 0, 20);
-    test(S("bdfjqgatlksriohemnpc"), 1, 0);
-    test(S("crnklpmegdqfiashtojb"), 1, 1);
-    test(S("ejqcnahdrkfsmptilgbo"), 1, 9);
-    test(S("jsbtafedocnirgpmkhql"), 1, 18);
-    test(S("prqgnlbaejsmkhdctoif"), 1, 19);
-    test(S("qnmodrtkebhpasifgcjl"), 10, 0);
-    test(S("pejafmnokrqhtisbcdgl"), 10, 1);
-    test(S("cpebqsfmnjdolhkratgi"), 10, 5);
-    test(S("odnqkgijrhabfmcestlp"), 10, 9);
-    test(S("lmofqdhpkibagnrcjste"), 10, 10);
-    test(S("lgjqketopbfahrmnsicd"), 19, 0);
-    test(S("ktsrmnqagdecfhijpobl"), 19, 1);
-    test(S("lsaijeqhtrbgcdmpfkno"), 20, 0);
-    test(S("dplqartnfgejichmoskb"), 21, 0);
-    }
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
 #if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(""), 0, 0);
-    test(S(""), 1, 0);
-    test(S("pniot"), 0, 0);
-    test(S("htaob"), 0, 1);
-    test(S("fodgq"), 0, 2);
-    test(S("hpqia"), 0, 4);
-    test(S("qanej"), 0, 5);
-    test(S("dfkap"), 1, 0);
-    test(S("clbao"), 1, 1);
-    test(S("ihqrf"), 1, 2);
-    test(S("mekdn"), 1, 3);
-    test(S("ngtjf"), 1, 4);
-    test(S("srdfq"), 2, 0);
-    test(S("qkdrs"), 2, 1);
-    test(S("ikcrq"), 2, 2);
-    test(S("cdaih"), 2, 3);
-    test(S("dmajb"), 4, 0);
-    test(S("karth"), 4, 1);
-    test(S("lhcdo"), 5, 0);
-    test(S("acbsj"), 6, 0);
-    test(S("pbsjikaole"), 0, 0);
-    test(S("pcbahntsje"), 0, 1);
-    test(S("mprdjbeiak"), 0, 5);
-    test(S("fhepcrntko"), 0, 9);
-    test(S("eqmpaidtls"), 0, 10);
-    test(S("joidhalcmq"), 1, 0);
-    test(S("omigsphflj"), 1, 1);
-    test(S("kocgbphfji"), 1, 4);
-    test(S("onmjekafbi"), 1, 8);
-    test(S("fbslrjiqkm"), 1, 9);
-    test(S("oqmrjahnkg"), 5, 0);
-    test(S("jeidpcmalh"), 5, 1);
-    test(S("schfalibje"), 5, 2);
-    test(S("crliponbqe"), 5, 4);
-    test(S("igdscopqtm"), 5, 5);
-    test(S("qngpdkimlc"), 9, 0);
-    test(S("thdjgafrlb"), 9, 1);
-    test(S("hcjitbfapl"), 10, 0);
-    test(S("mgojkldsqh"), 11, 0);
-    test(S("gfshlcmdjreqipbontak"), 0, 0);
-    test(S("nadkhpfemgclosibtjrq"), 0, 1);
-    test(S("nkodajteqplrbifhmcgs"), 0, 10);
-    test(S("ofdrqmkeblthacpgijsn"), 0, 19);
-    test(S("gbmetiprqdoasckjfhln"), 0, 20);
-    test(S("bdfjqgatlksriohemnpc"), 1, 0);
-    test(S("crnklpmegdqfiashtojb"), 1, 1);
-    test(S("ejqcnahdrkfsmptilgbo"), 1, 9);
-    test(S("jsbtafedocnirgpmkhql"), 1, 18);
-    test(S("prqgnlbaejsmkhdctoif"), 1, 19);
-    test(S("qnmodrtkebhpasifgcjl"), 10, 0);
-    test(S("pejafmnokrqhtisbcdgl"), 10, 1);
-    test(S("cpebqsfmnjdolhkratgi"), 10, 5);
-    test(S("odnqkgijrhabfmcestlp"), 10, 9);
-    test(S("lmofqdhpkibagnrcjste"), 10, 10);
-    test(S("lgjqketopbfahrmnsicd"), 19, 0);
-    test(S("ktsrmnqagdecfhijpobl"), 19, 1);
-    test(S("lsaijeqhtrbgcdmpfkno"), 20, 0);
-    test(S("dplqartnfgejichmoskb"), 21, 0);
-    }
+  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_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.require/contiguous.pass.cpp

 
 template <class C>
 TEST_CONSTEXPR_CXX20 void test_contiguous ( const C &c )
 {
     for ( 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() {
-  {
-    typedef std::string S;
-    test_contiguous(S());
-    test_contiguous(S("1"));
-    test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890"));
-  }
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  typedef Alloc<CharT> A;
+  typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> > S;
+  test_contiguous(S(A()));
+  test_contiguous(S("1", A()));
+  test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+}
+
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, std::allocator>() {
+  typedef std::allocator<char> A;
+  typedef std::basic_string<char, std::char_traits<char>, A> S;
 
-  {
-    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)));
-  }
+template <>
+TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+  test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
-  {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test_contiguous(S(A{}));
-    test_contiguous(S("1", A()));
-    test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-  }
+  test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_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.starts_with/starts_with.char.pass.cpp

 // <string>
 
 // constexpr bool starts_with(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    S  s1 {};
-    S  s2 { "abcde", 5 };
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  S s1{};
+  S s2{"abcde", 5};
 
-    ASSERT_NOEXCEPT(s1.starts_with('e'));
 
-    assert (!s1.starts_with('a'));
-    assert (!s1.starts_with('x'));
-    assert ( s2.starts_with('a'));
-    assert (!s2.starts_with('x'));
-  }
+  assert(!s1.starts_with('a'));
+  assert(!s1.starts_with('x'));
+  assert(s2.starts_with('a'));
+  assert(!s2.starts_with('x'));
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+#endif
+
   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

 // <string>
 
 // constexpr bool starts_with(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test() {
-  {
-    typedef std::string S;
-    const char *s = "abcde";
-    S  s0 {};
-    S  s1 { s, 1 };
-    S  s2 { s, 2 };
+template <class S>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  const char* s = "abcde";
+  S s0{};
+  S s1{s, 1};
+  S s2{s, 2};
   //     S  s3 { s, 3 };
   //     S  s4 { s, 4 };
   //     S  s5 { s, 5 };
-    S  sNot {"def", 3 };
+  S sNot{"def", 3};
 
-    LIBCPP_ASSERT_NOEXCEPT(s0.starts_with(""));
 
-    assert ( s0.starts_with(""));
-    assert (!s0.starts_with("a"));
+  assert(s0.starts_with(""));
+  assert(!s0.starts_with("a"));
 
-    assert ( s1.starts_with(""));
-    assert ( s1.starts_with("a"));
-    assert (!s1.starts_with("ab"));
-    assert (!s1.starts_with("abc"));
-    assert (!s1.starts_with("abcd"));
-    assert (!s1.starts_with("abcde"));
-    assert (!s1.starts_with("def"));
+  assert(s1.starts_with(""));
+  assert(s1.starts_with("a"));
+  assert(!s1.starts_with("ab"));
+  assert(!s1.starts_with("abc"));
+  assert(!s1.starts_with("abcd"));
+  assert(!s1.starts_with("abcde"));
+  assert(!s1.starts_with("def"));
 
-    assert ( s2.starts_with(""));
-    assert ( s2.starts_with("a"));
-    assert ( s2.starts_with("ab"));
-    assert (!s2.starts_with("abc"));
-    assert (!s2.starts_with("abcd"));
-    assert (!s2.starts_with("abcde"));
-    assert (!s2.starts_with("def"));
+  assert(s2.starts_with(""));
+  assert(s2.starts_with("a"));
+  assert(s2.starts_with("ab"));
+  assert(!s2.starts_with("abc"));
+  assert(!s2.starts_with("abcd"));
+  assert(!s2.starts_with("abcde"));
+  assert(!s2.starts_with("def"));
 
-    assert ( sNot.starts_with(""));
-    assert (!sNot.starts_with("a"));
-    assert (!sNot.starts_with("ab"));
-    assert (!sNot.starts_with("abc"));
-    assert (!sNot.starts_with("abcd"));
-    assert (!sNot.starts_with("abcde"));
-    assert ( sNot.starts_with("def"));
-  }
+  assert(sNot.starts_with(""));
+  assert(!sNot.starts_with("a"));
+  assert(!sNot.starts_with("ab"));
+  assert(!sNot.starts_with("abc"));
+  assert(!sNot.starts_with("abcd"));
+  assert(!sNot.starts_with("abcde"));
+  assert(sNot.starts_with("def"));
 
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<std::string>();
+#if TEST_STD_VER >= 11
+  test_string<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char> > >();
+#endif
+
   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

 // <string>
 
 // constexpr bool starts_with(string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
-constexpr bool test() {
-    typedef std::string S;
-    typedef std::string_view SV;
-    const char *s = "abcde";
+template <class CharT, template <class> class Alloc>
+TEST_CONSTEXPR_CXX20 void test_string() {
+  using S       = std::basic_string<CharT, std::char_traits<CharT>, Alloc<CharT> >;
+  using SV      = std::basic_string_view<CharT, std::char_traits<CharT> >;
+  const char* s = "abcde";
 
-    S   s0;
-    S   s1  { s, 1 };
-    S   s2  { s, 2 };
+  S 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 };
+  S sNot{"def", 3};
 
-    SV  sv0;
-    SV  sv1 { s, 1 };
-    SV  sv2 { s, 2 };
-    SV  sv3 { s, 3 };
-    SV  sv4 { s, 4 };
-    SV  sv5 { s, 5 };
-    SV svNot {"def", 3 };
+  SV sv0;
+  SV sv1{s, 1};
+  SV sv2{s, 2};
+  SV sv3{s, 3};
+  SV sv4{s, 4};
+  SV sv5{s, 5};
+  SV svNot{"def", 3};
 
-    ASSERT_NOEXCEPT(s0.starts_with(sv0));
 
-    assert ( s0.starts_with(sv0));
-    assert (!s0.starts_with(sv1));
+  assert(s0.starts_with(sv0));
+  assert(!s0.starts_with(sv1));
 
-    assert ( s1.starts_with(sv0));
-    assert ( s1.starts_with(sv1));
-    assert (!s1.starts_with(sv2));
-    assert (!s1.starts_with(sv3));
-    assert (!s1.starts_with(sv4));
-    assert (!s1.starts_with(sv5));
-    assert (!s1.starts_with(svNot));
+  assert(s1.starts_with(sv0));
+  assert(s1.starts_with(sv1));
+  assert(!s1.starts_with(sv2));
+  assert(!s1.starts_with(sv3));
+  assert(!s1.starts_with(sv4));
+  assert(!s1.starts_with(sv5));
+  assert(!s1.starts_with(svNot));
 
-    assert ( s2.starts_with(sv0));
-    assert ( s2.starts_with(sv1));
-    assert ( s2.starts_with(sv2));
-    assert (!s2.starts_with(sv3));
-    assert (!s2.starts_with(sv4));
-    assert (!s2.starts_with(sv5));
-    assert (!s2.starts_with(svNot));
+  assert(s2.starts_with(sv0));
+  assert(s2.starts_with(sv1));
+  assert(s2.starts_with(sv2));
+  assert(!s2.starts_with(sv3));
+  assert(!s2.starts_with(sv4));
+  assert(!s2.starts_with(sv5));
+  assert(!s2.starts_with(svNot));
 
-    assert ( sNot.starts_with(sv0));
-    assert (!sNot.starts_with(sv1));
-    assert (!sNot.starts_with(sv2));
-    assert (!sNot.starts_with(sv3));
-    assert (!sNot.starts_with(sv4));
-    assert (!sNot.starts_with(sv5));
-    assert ( sNot.starts_with(svNot));
+  assert(sNot.starts_with(sv0));
+  assert(!sNot.starts_with(sv1));
+  assert(!sNot.starts_with(sv2));
+  assert(!sNot.starts_with(sv3));
+  assert(!sNot.starts_with(sv4));
+  assert(!sNot.starts_with(sv5));
+  assert(sNot.starts_with(svNot));
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_string<char, std::allocator>();
+#if TEST_STD_VER >= 11
+  test_string<char, fancy_pointer_allocator>();
+#endif
 
-    return true;
 }
 
 int main(int, char**)
 {
   test();
   static_assert(test());
 
   return 0;
 }

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

 #include <string>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_traits.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 template <class Traits, class Allocator>
 void
 test()
 {
     typedef std::basic_string<typename Traits::char_type, Traits, Allocator> S;
 
     static_assert((std::is_same<typename S::traits_type, Traits>::value), "");
int main(int, char**)
     test<test_traits<char>, test_allocator<char> >();
     test<std::char_traits<wchar_t>, std::allocator<wchar_t> >();
     static_assert((std::is_same<std::basic_string<char>::traits_type,
                                 std::char_traits<char> >::value), "");
     static_assert((std::is_same<std::basic_string<char>::allocator_type,
                                 std::allocator<char> >::value), "");
 #if TEST_STD_VER >= 11
     test<std::char_traits<char>, min_allocator<char> >();
+    test<std::char_traits<char>, fancy_pointer_allocator<char> >();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/strings.erasure/erase.pass.cpp

void test()
   test0(S("aba"), opt('c'), S("aba"), 0);
 }
 
 int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+    test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char>>>();
 
     return 0;
 }

libcxx/test/std/strings/strings.erasure/erase_if.pass.cpp

void test()
     test0(S("aba"), True, S(""), 3);
 }
 
 int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+    test<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char>>>();
 
     return 0;
 }

libcxx/test/support/test_allocator.h

 #include <type_traits>
 #include <new>
 #include <memory>
 #include <utility>
 #include <cstddef>
 #include <cstdlib>
 #include <climits>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 
 template <class Alloc>
 TEST_CONSTEXPR_CXX20 inline typename std::allocator_traits<Alloc>::size_type alloc_max_size(Alloc const& a) {
   typedef std::allocator_traits<Alloc> AT;
   return AT::max_size(a);
 }
 
 struct test_allocator_statistics {
   int time_to_throw = 0;
-  int throw_after = INT_MAX;
-  int count = 0;
-  int alloc_count = 0;
-  int copied = 0;
-  int moved = 0;
-  int converted = 0;
+  int throw_after   = INT_MAX;
+  int count         = 0;
+  int alloc_count   = 0;
+  int copied        = 0;
+  int moved         = 0;
+  int converted     = 0;
 
   TEST_CONSTEXPR_CXX14 void clear() {
     assert(count == 0 && "clearing leaking allocator data?");
-    count = 0;
+    count         = 0;
     time_to_throw = 0;
-    alloc_count = 0;
-    throw_after = INT_MAX;
+    alloc_count   = 0;
+    throw_after   = INT_MAX;
     clear_ctor_counters();
   }
 
   TEST_CONSTEXPR_CXX14 void clear_ctor_counters() {
-    copied = 0;
-    moved = 0;
+    copied    = 0;
+    moved     = 0;
     converted = 0;
   }
 };
 
 struct test_alloc_base {
   TEST_CONSTEXPR static const int destructed_value = -1;
-  TEST_CONSTEXPR static const int moved_value = INT_MAX;
+  TEST_CONSTEXPR static const int moved_value      = INT_MAX;
 };
 
 template <class T>
 class test_allocator {
-  int data_ = 0; // participates in equality
-  int id_ = 0;   // unique identifier, doesn't participate in equality
+  int data_                         = 0; // participates in equality
+  int id_                           = 0; // unique identifier, doesn't participate in equality
   test_allocator_statistics* stats_ = nullptr;
 
   template <class U>
   friend class test_allocator;
 
 public:
   typedef unsigned size_type;
   typedef int difference_type;
public:
   TEST_CONSTEXPR_CXX14 explicit test_allocator(test_allocator_statistics* stats) TEST_NOEXCEPT : stats_(stats) {
     if (stats_ != nullptr)
       ++stats_->count;
   }
 
   TEST_CONSTEXPR explicit test_allocator(int data) TEST_NOEXCEPT : data_(data) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), stats_(stats) {
+      : data_(data),
+        stats_(stats) {
     if (stats != nullptr)
       ++stats_->count;
   }
 
   TEST_CONSTEXPR explicit test_allocator(int data, int id) TEST_NOEXCEPT : data_(data), id_(id) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, int id, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), id_(id), stats_(stats) {
+      : data_(data),
+        id_(id),
+        stats_(stats) {
     if (stats_ != nullptr)
       ++stats_->count;
   }
 
   TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator& a) TEST_NOEXCEPT
-    : data_(a.data_), id_(a.id_), stats_(a.stats_) {
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {
     assert(a.data_ != test_alloc_base::destructed_value && a.id_ != test_alloc_base::destructed_value &&
            "copying from destroyed allocator");
     if (stats_ != nullptr) {
       ++stats_->count;
       ++stats_->copied;
     }
   }
 
   TEST_CONSTEXPR_CXX14 test_allocator(test_allocator&& a) TEST_NOEXCEPT : data_(a.data_), id_(a.id_), stats_(a.stats_) {
     if (stats_ != nullptr) {
       ++stats_->count;
       ++stats_->moved;
     }
     assert(a.data_ != test_alloc_base::destructed_value && a.id_ != test_alloc_base::destructed_value &&
            "moving from destroyed allocator");
     a.data_ = test_alloc_base::moved_value;
-    a.id_ = test_alloc_base::moved_value;
+    a.id_   = test_alloc_base::moved_value;
   }
 
   template <class U>
   TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
-      : data_(a.data_), id_(a.id_), stats_(a.stats_) {
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {
     if (stats_ != nullptr) {
       ++stats_->count;
       ++stats_->converted;
     }
   }
 
   TEST_CONSTEXPR_CXX20 ~test_allocator() TEST_NOEXCEPT {
     assert(data_ != test_alloc_base::destructed_value);
     assert(id_ != test_alloc_base::destructed_value);
     if (stats_ != nullptr)
       --stats_->count;
     data_ = test_alloc_base::destructed_value;
-    id_ = test_alloc_base::destructed_value;
+    id_   = test_alloc_base::destructed_value;
   }
 
   TEST_CONSTEXPR pointer address(reference x) const { return &x; }
   TEST_CONSTEXPR const_pointer address(const_reference x) const { return &x; }
 
   TEST_CONSTEXPR_CXX14 pointer allocate(size_type n, const void* = 0) {
     assert(data_ != test_alloc_base::destructed_value);
     if (stats_ != nullptr) {
#endif
   TEST_CONSTEXPR friend bool operator!=(const test_allocator& x, const test_allocator& y) { return !(x == y); }
 
   TEST_CONSTEXPR int get_data() const { return data_; }
   TEST_CONSTEXPR int get_id() const { return id_; }
 };
 
 template <class T>
 class non_default_test_allocator {
-  int data_ = 0;
+  int data_                         = 0;
   test_allocator_statistics* stats_ = nullptr;
 
   template <class U>
   friend class non_default_test_allocator;
 
 public:
   typedef unsigned size_type;
   typedef int difference_type;
   typedef T value_type;
   typedef value_type* pointer;
   typedef const value_type* const_pointer;
   typedef typename std::add_lvalue_reference<value_type>::type reference;
   typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
 
   template <class U>
   struct rebind {
     typedef non_default_test_allocator<U> other;
   };
 
   TEST_CONSTEXPR_CXX14
   explicit non_default_test_allocator(int i, test_allocator_statistics* stats = nullptr) TEST_NOEXCEPT
-      : data_(i), stats_(stats) {
+      : data_(i),
+        stats_(stats) {
     if (stats_ != nullptr) {
       ++stats_->count;
     }
   }
 
   TEST_CONSTEXPR_CXX14
   non_default_test_allocator(const non_default_test_allocator& a) TEST_NOEXCEPT : data_(a.data_), stats_(a.stats_) {
     if (stats_ != nullptr)
       ++stats_->count;
   }
 
   template <class U>
   TEST_CONSTEXPR_CXX14 non_default_test_allocator(const non_default_test_allocator<U>& a) TEST_NOEXCEPT
-      : data_(a.data_), stats_(a.stats_) {
+      : data_(a.data_),
+        stats_(a.stats_) {
     if (stats_ != nullptr)
       ++stats_->count;
   }
 
   TEST_CONSTEXPR_CXX20 ~non_default_test_allocator() TEST_NOEXCEPT {
     assert(data_ != test_alloc_base::destructed_value);
     if (stats_ != nullptr)
       --stats_->count;
public:
 
   TEST_CONSTEXPR friend bool operator!=(const non_default_test_allocator& x, const non_default_test_allocator& y) {
     return !(x == y);
   }
 };
 
 template <>
 class test_allocator<void> {
-  int data_ = 0;
-  int id_ = 0;
+  int data_                         = 0;
+  int id_                           = 0;
   test_allocator_statistics* stats_ = nullptr;
 
   template <class U>
   friend class test_allocator;
 
 public:
   typedef unsigned size_type;
   typedef int difference_type;
   typedef void value_type;
   typedef value_type* pointer;
   typedef const value_type* const_pointer;
 
   template <class U>
   struct rebind {
     typedef test_allocator<U> other;
   };
 
   TEST_CONSTEXPR test_allocator() TEST_NOEXCEPT = default;
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(test_allocator_statistics* stats) TEST_NOEXCEPT : stats_(stats) {}
 
   TEST_CONSTEXPR explicit test_allocator(int data) TEST_NOEXCEPT : data_(data) {}
 
   TEST_CONSTEXPR explicit test_allocator(int data, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), stats_(stats)
-  {}
+      : data_(data),
+        stats_(stats) {}
 
   TEST_CONSTEXPR explicit test_allocator(int data, int id) : data_(data), id_(id) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, int id, test_allocator_statistics* stats) TEST_NOEXCEPT
-      : data_(data), id_(id), stats_(stats)
-  {}
+      : data_(data),
+        id_(id),
+        stats_(stats) {}
 
   TEST_CONSTEXPR_CXX14 explicit test_allocator(const test_allocator& a) TEST_NOEXCEPT
-      : data_(a.data_), id_(a.id_), stats_(a.stats_)
-  {}
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {}
 
   template <class U>
   TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
-      : data_(a.data_), id_(a.id_), stats_(a.stats_)
-  {}
+      : data_(a.data_),
+        id_(a.id_),
+        stats_(a.stats_) {}
 
   TEST_CONSTEXPR_CXX20 ~test_allocator() TEST_NOEXCEPT {
     data_ = test_alloc_base::destructed_value;
-    id_ = test_alloc_base::destructed_value;
+    id_   = test_alloc_base::destructed_value;
   }
 
   TEST_CONSTEXPR int get_id() const { return id_; }
   TEST_CONSTEXPR int get_data() const { return data_; }
 
   TEST_CONSTEXPR friend bool operator==(const test_allocator& x, const test_allocator& y) { return x.data_ == y.data_; }
   TEST_CONSTEXPR friend bool operator!=(const test_allocator& x, const test_allocator& y) { return !(x == y); }
 };
struct Tag_X {
   // MoveInsertable into vector<X, TaggingAllocator<X>>, and
   TEST_CONSTEXPR Tag_X(Ctor_Tag, Tag_X&&) {}
 
   // EmplaceConstructible into vector<X, TaggingAllocator<X>> from args.
   template <typename... Args>
   TEST_CONSTEXPR Tag_X(Ctor_Tag, Args&&...) {}
 
   // not DefaultConstructible, CopyConstructible or MoveConstructible.
-  Tag_X() = delete;
+  Tag_X()             = delete;
   Tag_X(const Tag_X&) = delete;
-  Tag_X(Tag_X&&) = delete;
+  Tag_X(Tag_X&&)      = delete;
 
   // CopyAssignable.
   TEST_CONSTEXPR_CXX14 Tag_X& operator=(const Tag_X&) { return *this; };
 
   // MoveAssignable.
   TEST_CONSTEXPR_CXX14 Tag_X& operator=(Tag_X&&) { return *this; };
 
 private:
   ~Tag_X() = default;
   // Erasable from vector<X, TaggingAllocator<X>>.
   friend class TaggingAllocator<Tag_X>;
 };
 
 template <typename T>
 class TaggingAllocator {
 public:
-  using value_type = T;
+  using value_type   = T;
   TaggingAllocator() = default;
 
   template <typename U>
   TEST_CONSTEXPR TaggingAllocator(const TaggingAllocator<U>&) {}
 
   template <typename... Args>
   TEST_CONSTEXPR_CXX20 void construct(Tag_X* p, Args&&... args) {
 #if TEST_STD_VER > 17
#endif
 
   TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
   TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t n) { std::allocator<T>().deallocate(p, n); }
 };
 
 template <std::size_t MaxAllocs>
 struct limited_alloc_handle {
   std::size_t outstanding_ = 0;
-  void* last_alloc_ = nullptr;
+  void* last_alloc_        = nullptr;
 
   template <class T>
   TEST_CONSTEXPR_CXX20 T* allocate(std::size_t N) {
     if (N + outstanding_ > MaxAllocs)
       TEST_THROW(std::bad_alloc());
-    auto alloc = std::allocator<T>().allocate(N);
+    auto alloc  = std::allocator<T>().allocate(N);
     last_alloc_ = alloc;
     outstanding_ += N;
     return alloc;
   }
 
   template <class T>
   TEST_CONSTEXPR_CXX20 void deallocate(T* ptr, std::size_t N) {
     if (ptr == last_alloc_) {
TEST_CONSTEXPR_CXX20 thread_unsafe_shared_ptr<T> make_thread_unsafe_shared(Args... args) {
 
   thread_unsafe_shared_ptr<T> ptr;
   std::allocator<control_block_type> alloc;
   ptr.block = allocator_traits::allocate(alloc, 1);
   allocator_traits::construct(alloc, ptr.block, std::forward<Args>(args)...);
 
   return ptr;
 }
+
 } // namespace detail
 
+template <class T>
+class fancy_pointer {
+public:
+  // For the std::pointer_traits interface.
+  using pointer         = T*;
+  using element_type    = T;
+  using difference_type = std::ptrdiff_t;
+
+  template <class U>
+  using rebind = fancy_pointer<U>;
+
+  // For the std::iterator_traits interface.
+  using value_type        = typename std::remove_cv<T>::type;
+  using reference         = typename std::add_lvalue_reference<T>::type;
+  using iterator_category = std::random_access_iterator_tag;
+
+  TEST_CONSTEXPR_CXX14 fancy_pointer() TEST_NOEXCEPT : ptr_(nullptr) {}
+  TEST_CONSTEXPR_CXX14 fancy_pointer(T* p) TEST_NOEXCEPT : ptr_(p) {}
+
+  template <typename T2>
+  TEST_CONSTEXPR_CXX14 fancy_pointer(const fancy_pointer<T2>& other) TEST_NOEXCEPT : ptr_(other.get()) {}
+
+  TEST_CONSTEXPR_CXX14 operator T*() const TEST_NOEXCEPT { return ptr_; }
+  TEST_CONSTEXPR_CXX14 fancy_pointer(fancy_pointer&&) TEST_NOEXCEPT                 = default;
+  TEST_CONSTEXPR_CXX14 fancy_pointer(const fancy_pointer&) TEST_NOEXCEPT            = default;
+  TEST_CONSTEXPR_CXX14 fancy_pointer& operator=(fancy_pointer&&) TEST_NOEXCEPT      = default;
+  TEST_CONSTEXPR_CXX14 fancy_pointer& operator=(const fancy_pointer&) TEST_NOEXCEPT = default;
+  TEST_CONSTEXPR_CXX20 ~fancy_pointer() TEST_NOEXCEPT                               = default;
+  TEST_CONSTEXPR_CXX14 operator fancy_pointer<const T>() const TEST_NOEXCEPT { return fancy_pointer<const T>(get()); }
+  TEST_CONSTEXPR_CXX14 T& operator*() const TEST_NOEXCEPT { return *ptr_; }
+  TEST_CONSTEXPR_CXX14 T* operator->() const TEST_NOEXCEPT { return ptr_; }
+  TEST_CONSTEXPR_CXX14 explicit operator bool() const TEST_NOEXCEPT { return ptr_; }
+  TEST_CONSTEXPR_CXX14 T* get() const TEST_NOEXCEPT { return ptr_; }
+
+  TEST_CONSTEXPR_CXX14 fancy_pointer& operator++() TEST_NOEXCEPT {
+    ++ptr_;
+    return *this;
+  }
+  TEST_CONSTEXPR_CXX14 fancy_pointer operator++(int) TEST_NOEXCEPT {
+    fancy_pointer tmp(*this);
+    ++ptr_;
+    return tmp;
+  }
+
+  TEST_CONSTEXPR_CXX14 fancy_pointer& operator--() TEST_NOEXCEPT {
+    --ptr_;
+    return *this;
+  }
+  TEST_CONSTEXPR_CXX14 fancy_pointer operator--(int) TEST_NOEXCEPT {
+    fancy_pointer tmp(*this);
+    --ptr_;
+    return tmp;
+  }
+
+  TEST_CONSTEXPR_CXX14 fancy_pointer& operator+=(difference_type n) TEST_NOEXCEPT {
+    ptr_ += n;
+    return *this;
+  }
+
+  TEST_CONSTEXPR_CXX14 fancy_pointer& operator-=(difference_type n) TEST_NOEXCEPT {
+    ptr_ -= n;
+    return *this;
+  }
+
+  TEST_CONSTEXPR_CXX14 fancy_pointer operator+(difference_type n) const TEST_NOEXCEPT {
+    fancy_pointer tmp(*this);
+    tmp += n;
+    return tmp;
+  }
+
+  TEST_CONSTEXPR_CXX14 fancy_pointer operator-(difference_type n) const TEST_NOEXCEPT {
+    fancy_pointer tmp(*this);
+    tmp -= n;
+    return tmp;
+  }
+
+  TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const TEST_NOEXCEPT { return ptr_[n]; }
+
+  friend TEST_CONSTEXPR_CXX14 fancy_pointer operator+(difference_type x, fancy_pointer y) TEST_NOEXCEPT {
+    return y + x;
+  }
+
+  friend TEST_CONSTEXPR_CXX14 bool operator<(fancy_pointer x, fancy_pointer y) TEST_NOEXCEPT { return x.ptr_ < y.ptr_; }
+  friend TEST_CONSTEXPR_CXX14 bool operator>(fancy_pointer x, fancy_pointer y) TEST_NOEXCEPT { return y < x; }
+  friend TEST_CONSTEXPR_CXX14 bool operator<=(fancy_pointer x, fancy_pointer y) TEST_NOEXCEPT { return !(y < x); }
+  friend TEST_CONSTEXPR_CXX14 bool operator>=(fancy_pointer x, fancy_pointer y) TEST_NOEXCEPT { return !(x < y); }
+
+  static TEST_CONSTEXPR_CXX14 fancy_pointer pointer_to(reference ref) TEST_NOEXCEPT { return fancy_pointer(&ref); }
+
+  T* ptr_;
+};
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 typename fancy_pointer<T>::difference_type
+operator-(fancy_pointer<T> x, fancy_pointer<T> y) TEST_NOEXCEPT {
+  return x.ptr_ - y.ptr_;
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 typename fancy_pointer<T>::difference_type
+operator-(fancy_pointer<const T> x, fancy_pointer<T> y) TEST_NOEXCEPT {
+  return x.ptr_ - y.ptr_;
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 typename fancy_pointer<T>::difference_type
+operator-(fancy_pointer<T> x, fancy_pointer<const T> y) TEST_NOEXCEPT {
+  return x.ptr_ - y.ptr_;
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 typename fancy_pointer<T>::difference_type
+operator-(fancy_pointer<const T> x, fancy_pointer<const T> y) TEST_NOEXCEPT {
+  return x.ptr_ - y.ptr_;
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator==(fancy_pointer<T> x, fancy_pointer<T> y) TEST_NOEXCEPT {
+  return x.get() == y.get();
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator==(fancy_pointer<const T> x, fancy_pointer<T> y) TEST_NOEXCEPT {
+  return x.get() == y.get();
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator==(fancy_pointer<T> x, fancy_pointer<const T> y) TEST_NOEXCEPT {
+  return x.get() == y.get();
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator==(fancy_pointer<const T> x, fancy_pointer<const T> y) TEST_NOEXCEPT {
+  return x.get() == y.get();
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator!=(fancy_pointer<T> x, fancy_pointer<T> y) TEST_NOEXCEPT {
+  return !(x == y);
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator!=(fancy_pointer<const T> x, fancy_pointer<T> y) TEST_NOEXCEPT {
+  return !(x == y);
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator!=(fancy_pointer<T> x, fancy_pointer<const T> y) TEST_NOEXCEPT {
+  return !(x == y);
+}
+
+template <typename T>
+TEST_CONSTEXPR_CXX14 bool operator!=(fancy_pointer<const T> x, fancy_pointer<const T> y) TEST_NOEXCEPT {
+  return !(x == y);
+}
+
+template <class T>
+class fancy_pointer_allocator : public std::allocator<T> {
+  typedef std::allocator<T> base;
+
+public:
+  typedef T value_type;
+  typedef fancy_pointer<T> pointer;
+  typedef fancy_pointer<const T> const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  template <class U>
+  struct rebind {
+    typedef fancy_pointer_allocator<U> other;
+  };
+
+  TEST_CONSTEXPR_CXX20 fancy_pointer_allocator() TEST_NOEXCEPT {}
+
+  template <class U>
+  TEST_CONSTEXPR explicit fancy_pointer_allocator(fancy_pointer_allocator<U>) TEST_NOEXCEPT {}
+
+  TEST_CONSTEXPR_CXX20 pointer allocate(size_t n) { return base::allocate(n); }
+  TEST_CONSTEXPR_CXX20 void deallocate(pointer p, size_t n) { return base::deallocate(p, n); }
+
+#if TEST_STD_VER > 20
+  TEST_CONSTEXPR_CXX20 std::allocation_result<pointer> allocate_at_least(std::size_t n) { return {allocate(n), n}; }
+#endif
+};
+
 template <class T, std::size_t N>
 class limited_allocator {
   template <class U, std::size_t UN>
   friend class limited_allocator;
   typedef limited_alloc_handle<N> BuffT;
   detail::thread_unsafe_shared_ptr<BuffT> handle_;
 
 public: