[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

680

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

680

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

680

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.

773

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 ↗

(On Diff #461567)

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?

115 ↗

(On Diff #461264)

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

680

Done (Removed static assert) .

773

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 ↗

(On Diff #461567)

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

115 ↗

(On Diff #461264)

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

773

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

773

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");
 
     static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
                   "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
                   "original allocator");
 
     // TODO: Implement iterator bounds checking without requiring the global database.
     typedef __wrap_iter<pointer>                         iterator;
     typedef __wrap_iter<const_pointer>                   const_iterator;
     typedef std::reverse_iterator<iterator>              reverse_iterator;
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.");
 
-    union __ulx{__long __lx; __short __lxx;};
+    union __ulx {
+      __long __lx;
+      __short __lxx;
+    };
 
     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 (C++03 doesn't allow unions to
+    // contain members with non-trivial special member functions). In this case, the corresponding special member
+    // function in the union will be deleted and therefore must be explicitly defined. Therefore, 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.
+    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<char16_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/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"
 
 template <class S>
 void test() {
   S s;
   TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): 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.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"
 
 template <class S>
 void test() {
   const S s;
   TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): 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.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"
 
 template <class S>
 void test() {
   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"
 
 template <class S>
 void test() {
   const S s;
   assert(s[0] == 0);
   TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 }
 
 int main(int, char**) {
   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"
 
 template <class S>
 void test() {
   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"
 
 template <class S>
 void test() {
   S s;
   assert(s[0] == 0);
   TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 }
 
 int main(int, char**) {
   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>
 TEST_CONSTEXPR_CXX20 bool test() {
   // Test that a call to reserve() does shrink the string.
   if (!TEST_IS_CONSTANT_EVALUATED) {
     S s(1000, 'a');
     typename S::size_type old_cap = s.capacity();
     s.resize(20);
TEST_CONSTEXPR_CXX20 bool test() {
   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>, fancy_pointer_allocator<char> > >();
 #endif
 
 #if TEST_STD_VER > 17
   static_assert(test<std::string>());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 bool test() {
   assert(s2.capacity() < sizeof(S));
 
   return true;
 }
 
 int main(int, char**) {
   test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #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::basic_string<char, std::char_traits<char>, test_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>, test_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/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"
 
 template <class C>
 void test() {
   C c(1, '\0');
   typename C::iterator i = c.begin();
   i += 1;
   assert(i == c.end());
   i = c.begin();
   TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
 }
 
 int main(int, char**) {
   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"
 
 template <class S>
 void test() {
   S s1;
   S s2;
   TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
 }
 
 int main(int, char**) {
   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"
 
 template <class C>
 void test() {
   C c(1, '\0');
   typename C::iterator i = c.end();
   --i;
   assert(i == c.begin());
   TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
 }
 
 int main(int, char**) {
   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"
 
 template <class C>
 void test() {
   C c(1, '\0');
   typename C::iterator i = c.end();
   TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
 }
 
 int main(int, char**) {
   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"
 
 template <class C>
 void test() {
   C c(1, '\0');
   typename C::iterator i = c.begin();
   ++i;
   assert(i == c.end());
   TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
 }
 
 int main(int, char**) {
   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"
 
 template <class C>
 void test() {
   using T = decltype(uint8_t() - uint8_t());
   C c(1, '\0');
   typename C::iterator i = c.begin();
   assert(i[0] == 0);
   TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
 }
 
 int main(int, char**) {
   test<std::string>();
   test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  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"
 
 template <class S>
 void test() {
   S s1;
   S s2;
   TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
 }
 
 int main(int, char**) {
   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"
 
 template <class S>
 void test() {
   S l1("123");
   typename S::const_iterator i = l1.end();
   TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
 }
 
 int main(int, char**) {
   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"
 
 template <class S>
 void test() {
   S s;
   TEST_LIBCPP_ASSERT_FAILURE(s.pop_back(), "string::pop_back(): string is already empty");
 }
 
 int main(int, char**) {
   test<std::string>();
+  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"
 
 template <class S>
 void test() {
   S l1("123");
   S l2("123");
   typename S::const_iterator i = l2.begin();
   TEST_LIBCPP_ASSERT_FAILURE(
       l1.erase(i), "string::erase(iterator) called with an iterator not referring to this string");
 }
 
 int main(int, char**) {
   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/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"
 
 template <class S>
 void test() {
   // With first iterator from another container
   {
     S l1("123");
     S l2("123");
     TEST_LIBCPP_ASSERT_FAILURE(
// With an invalid range
     TEST_LIBCPP_ASSERT_FAILURE(
         l1.erase(l1.cbegin() + 1, l1.cbegin()), "string::erase(first, last) called with invalid range");
   }
 }
 
 int main(int, char**) {
   test<std::string>();
   test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  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_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"
 
 template <class S>
 void test() {
   S s;
   S s2;
   TEST_LIBCPP_ASSERT_FAILURE(
       s.insert(s2.begin(), '1'),
       "string::insert(iterator, character) called with an iterator not referring to this string");
 }
 
 int main(int, char**) {
   test<std::string>();
+  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"
 
 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"
 
 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"
 
 TEST_CONSTEXPR_CXX20 void write_c_str(char* buf, int size) {
   for (int i = 0; i < size; ++i) {
     buf[i] = 'a';
   }
   buf[size] = '\0';
 }
 
TEST_CONSTEXPR_CXX20 bool test() {
   test_basic<S>();
   test_buffer_usage<S>();
 
   return true;
 }
 
 int main(int, char**) {
   test<std::string>();
+#if TEST_STD_VER >= 11
+  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>, fancy_pointer_allocator<char> > >());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test_hash_enabled_for_type<std::wstring>();
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
     test_hash_enabled_for_type<std::u8string>();
 #endif
     test_hash_enabled_for_type<std::u16string>();
     test_hash_enabled_for_type<std::u32string>();
     test_hash_enabled_for_type<std::basic_string<char, std::char_traits<char>, test_allocator<char>>>();
+    test_hash_enabled_for_type<std::basic_string<char, std::char_traits<char>, fancy_pointer_allocator<char>>>();
     test_hash_disabled_for_type<std::basic_string<MyChar, std::char_traits<MyChar>, std::allocator<MyChar>>>();
     test_hash_disabled_for_type<std::basic_string<char, constexpr_char_traits<char>, std::allocator<char>>>();
   }
 
   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 "make_string.h"
 #include "test_macros.h"
 #include "type_algorithms.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type pos) {
   const S& cs = s;

 }
 
 struct TestCaller {
   template <class T>
   TEST_CONSTEXPR_CXX20 void operator()() {
     test_string<std::basic_string<T> >();
 #if TEST_STD_VER >= 11
     test_string<std::basic_string<T, std::char_traits<T>, min_allocator<T> > >();
+    test_string<std::basic_string<T, std::char_traits<T>, fancy_pointer_allocator<T> > >();
 #endif
   }
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
   meta::for_each(meta::character_types(), TestCaller());
 
   return true;

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'));
 }
 
 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>, 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.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'));
 }
 
 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>, 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.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>, 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.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;
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try
TEST_CONSTEXPR_CXX20 void test_string<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >() {
   s.assign(100, 'a');
   s.erase(50);
   test(s, alloc_stats);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
 #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.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);
 }
 
 template <class S>
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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.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));
 }
 
 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>, 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.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());
 }
 
 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>, 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.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&) {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 #if TEST_STD_VER > 17
 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**) {
   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>
 TEST_CONSTEXPR_CXX20 void test(const S& s) {
   assert(s.max_size() >= s.size());
   S s2(s);
   const size_t sz = s2.max_size() + 1;
   try {
     s2.resize(sz, 'x');
void test_string() {
   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>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 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_string() {
   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>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 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_CONSTEXPR_CXX20 void test_string() {
     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>, 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.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);
void test_value_categories() {
   struct RefQualified {
     int operator()(char*, size_t) && { return 0; }
   };
   s.resize_and_overwrite(10, RefQualified{});
 }
 
 int main(int, char**) {
   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_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_string() {
   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>, 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.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(S("12345678901234567890123456789012345678901234567890"),
        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>, 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.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);
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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.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);
 }
 
 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>, 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.cons/T_size_size.pass.cpp

TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   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
   {
     using S    = std::string;
     using SV   = std::string_view;
     S s        = "ABCD";
     SV sv      = "EFGH";
     char arr[] = "IJKL";
 

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{})), "");
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "");

 }
 
 #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());
 }
 
 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>, 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.cons/copy.pass.cpp

TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
 }
 
 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
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   test(S("1"), A(5));
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
   test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_allocator>();
 
 #  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";
 

libcxx/test/std/strings/basic.string/string.cons/copy_assignment.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 s1, const S& s2) {
   s1 = s2;
   LIBCPP_ASSERT(s1.__invariants());
   assert(s1 == s2);
   assert(s1.capacity() >= s1.size());
 }
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> > >();
+  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 = {"abc", 1};
     assert(s.size() == 1);
     assert(s == "a");

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

 #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,
                      "");
+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,
                      "");
 #endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
   std::string str;
   assert(str.empty());

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

 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>, 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)));
     str2 = "long long string so no SSO";

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

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   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**) {
   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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_case() {
   S s;
   s = {'a', 'b', 'c'};
   assert(s == "abc");
 }
 
 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**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test(const Alloc& a) {
   test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 50));
   test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s + 50), a);
 }
 
 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), "");
   }
 
   return true;
 }

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

TEST_CONSTEXPR_CXX20 bool test() {
     std::basic_string s1(s, s + 10); // Can't use {} here
     test_string<char, std::allocator>(s, std::move(s1));
   }
   {
     const char* s = "12345678901234";
     std::basic_string s1{s, s + 10, std::allocator<char>{}};
     test_string<char, std::allocator>(s, std::move(s1));
   }
+  {
+    const char* s = "12345678901234";
+    std::basic_string s1{s, s + 10, fancy_pointer_allocator<char>{}};
+    test_string<char, fancy_pointer_allocator>(s, std::move(s1));
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     const wchar_t* s = L"12345678901234";
     std::basic_string s1{s, s + 10, test_allocator<wchar_t>{}};
     test_string<wchar_t, test_allocator>(s, std::move(s1));
   }
   {
     const char16_t* s = u"12345678901234";
     std::basic_string s1{s, s + 10, min_allocator<char16_t>{}};
     test_string<char16_t, min_allocator>(s, std::move(s1));
   }
+  {
+    const char16_t* s = u"12345678901234";
+    std::basic_string s1{s, s + 10, fancy_pointer_allocator<char16_t>{}};
+    test_string<char16_t, fancy_pointer_allocator>(s, std::move(s1));
+  }
 #endif
   {
     const char32_t* s = U"12345678901234";
     std::basic_string s1{s, s + 10, explicit_allocator<char32_t>{}};
     test_string<char32_t, explicit_allocator>(s, std::move(s1));
   }
+  {
+    const char32_t* s = U"12345678901234";
+    std::basic_string s1{s, s + 10, fancy_pointer_allocator<char32_t>{}};
+    test_string<char32_t, fancy_pointer_allocator>(s, std::move(s1));
+  }
 
   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/move.pass.cpp

TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   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**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

#endif
     S s2(std::move(s1), A(1, &alloc_stats));
   }
   assert(alloc_stats.alloc_count == alloc_count);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, test_allocator>();
   test_string<char, min_allocator>();
+  test_string<char, fancy_pointer_allocator>();
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

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;
     static_assert(!std::is_nothrow_move_assignable<C>::value, "");
   }
   {
+    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, "");
 #else
     static_assert(!std::is_nothrow_move_assignable<C>::value, "");
 #endif
   }

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

test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
        S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
          "1234567890123456789012345678901234567890123456789012345678901234567890"),
        S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
-#if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
-#endif
+  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.cons/move_noexcept.pass.cpp

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>, 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, "");
 #endif
   }
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test(const Alloc& 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**) {
   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);
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>, 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.cons/pointer_size_alloc.pass.cpp

TEST_CONSTEXPR_CXX20 void test(const Alloc& 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");
   }

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

TEST_CONSTEXPR_CXX20 void test_string<test_allocator<char> >() {
   test(static_cast<char>(100), static_cast<char>(65));
   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**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test_string(const Alloc& 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**) {
   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);
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>, 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.cons/string_view_deduction.pass.cpp

TEST_CONSTEXPR_CXX20 bool test() {
     std::basic_string s1(sv);
     test<char, std::allocator>(std::move(sv), std::move(s1));
   }
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, std::allocator<char>{}};
     test<char, std::allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::string_view sv = "12345678901234";
+    std::basic_string s1{sv, fancy_pointer_allocator<char>{}};
+    test<char, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, test_allocator<wchar_t>{}};
     test<wchar_t, test_allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::wstring_view sv = L"12345678901234";
+    std::basic_string s1{sv, fancy_pointer_allocator<wchar_t>{}};
+    test<wchar_t, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, min_allocator<char8_t>{}};
     test<char8_t, min_allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::u8string_view sv = u8"12345678901234";
+    std::basic_string s1{sv, fancy_pointer_allocator<char8_t>{}};
+    test<char8_t, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 #endif
   {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, min_allocator<char16_t>{}};
     test<char16_t, min_allocator>(std::move(sv), std::move(s1));
   }
   {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, explicit_allocator<char32_t>{}};
     test<char32_t, explicit_allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::u32string_view sv = U"12345678901234";
+    std::basic_string s1{sv, fancy_pointer_allocator<char32_t>{}};
+    test<char32_t, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 
   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

 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4};
     test<char, std::allocator>(std::move(sv), std::move(s1));
   }
-
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4, std::allocator<char>{}};
     test<char, std::allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::string_view sv = "12345678901234";
+    std::basic_string s1{sv, 0, 4, fancy_pointer_allocator<char>{}};
+    test<char, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::wstring_view sv = L"12345678901234";
     std::basic_string s1{sv, 0, 4, test_allocator<wchar_t>{}};
     test<wchar_t, test_allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::wstring_view sv = L"12345678901234";
+    std::basic_string s1{sv, 0, 4, fancy_pointer_allocator<wchar_t>{}};
+    test<wchar_t, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   {
     std::u8string_view sv = u8"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char8_t>{}};
     test<char8_t, min_allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::u8string_view sv = u8"12345678901234";
+    std::basic_string s1{sv, 0, 4, fancy_pointer_allocator<char8_t>{}};
+    test<char8_t, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 #endif
   {
     std::u16string_view sv = u"12345678901234";
     std::basic_string s1{sv, 0, 4, min_allocator<char16_t>{}};
     test<char16_t, min_allocator>(std::move(sv), std::move(s1));
   }
   {
     std::u32string_view sv = U"12345678901234";
     std::basic_string s1{sv, 0, 4, explicit_allocator<char32_t>{}};
     test<char32_t, explicit_allocator>(std::move(sv), std::move(s1));
   }
+  {
+    std::u32string_view sv = U"12345678901234";
+    std::basic_string s1{sv, 0, 4, fancy_pointer_allocator<char32_t>{}};
+    test<char32_t, fancy_pointer_allocator>(std::move(sv), std::move(s1));
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   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
-  { test_string<char, min_allocator>(); }
+  {
+    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
   test_lwg2583();
 
   return 0;
 }

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

constexpr void test_string(const typename S::allocator_type& alloc) {
   test_string_pos_n_alloc<S>(STR("long long string so no SSO"), 27, 10, alloc, should_throw_exception);
 }
 
 template <class CharT, class CharTraits>
 constexpr void test_allocators() {
   test_string<std::basic_string<CharT, CharTraits, std::allocator<CharT>>>(std::allocator<CharT>{});
   test_string<std::basic_string<CharT, CharTraits, min_allocator<CharT>>>(min_allocator<CharT>{});
   test_string<std::basic_string<CharT, CharTraits, test_allocator<CharT>>>(test_allocator<CharT>{42});
+  test_string<std::basic_string<CharT, CharTraits, fancy_pointer_allocator<CharT>>>(fancy_pointer_allocator<CharT>{});
 }
 
 template <class CharT>
 constexpr bool test_char_traits() {
   test_allocators<CharT, std::char_traits<CharT>>();
   test_allocators<CharT, constexpr_char_traits<CharT>>();
 
   return true;

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"
 
 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'));
 }
 
 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.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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   const char* s = "abcde";
   S s0;
   S s1{s + 4, 1};
   S s3{s + 2, 3};
   S sNot{"xyz", 3};
TEST_CONSTEXPR_CXX20 void test_string() {
   assert(!sNot.contains("bcde"));
   assert(!sNot.contains("abcde"));
   assert(sNot.contains("xyz"));
   assert(!sNot.contains("zyx"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
+  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.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"
 
 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;
TEST_CONSTEXPR_CXX20 void test_string() {
   assert(!sNot.contains(sv5));
   assert(sNot.contains(svNot));
   assert(!sNot.contains(svNot2));
   assert(!sNot.contains(svNot3));
 }
 
 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.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"
 
 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'));
 }
 
 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.ptr.pass.cpp

 // <string>
 
 // constexpr bool ends_with(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_allocator.h"
 
 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};
TEST_CONSTEXPR_CXX20 void test_string() {
   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"
 
 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;
TEST_CONSTEXPR_CXX20 void test_string() {
   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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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.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());
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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.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());
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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.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());
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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.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());
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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.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());
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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.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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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.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());
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S());
   test(S("123"));
 }
 
 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/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>
TEST_CONSTEXPR_CXX20 void test_string() {
   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_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>, 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_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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s("123");
   s.append({'a', 'b', 'c'});
   assert(s == "123abc");
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
-#if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
-#endif
+  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_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(S("12345678901234567890"),
        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>, 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_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_string() {
   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>, 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());

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_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>, 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());

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 <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
 
 struct VeryLarge {
   long long a;
   char b;
 };
 
 namespace std {
 template <>
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345"), 'a', S("12345a"));
   test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   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);

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_string() {
   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>, 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/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_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>, 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");

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_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>, 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"));

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_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>, 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/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);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
   }
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>, 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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s("123");
   s.assign({'a', 'b', 'c'});
   assert(s == "abc");
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
-#if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
-#endif
+  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_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 + 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>, 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_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>, 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>, 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>, 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"), 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>, 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

TEST_CONSTEXPR_CXX20 void test_string<char, other_allocator>() {
   testAlloc(S(A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
   test_string<char, other_allocator>(); // has POCCA --> true
 #if TEST_STD_VER >= 11
   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);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
   }
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>, 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"));

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

TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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()) {
     typename S::size_type r    = cs.copy(s, n, pos);
     typename S::size_type rlen = std::min(n, cs.size() - pos);
     assert(r == rlen);
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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());
   assert(s[s.size()] == typename S::value_type());
   assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
   LIBCPP_ASSERT(s.__invariants());
   assert(s[s.size()] == typename S::value_type());
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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>, 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) {
     s.erase(pos, n);
     LIBCPP_ASSERT(s.__invariants());
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
   LIBCPP_ASSERT(s.__invariants());
   assert(s == expected);
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s("123456");
   typename S::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
   assert(i - s.begin() == 3);
   assert(s == "123abc456");
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   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());
   assert(i - s.begin() == pos);
   assert(s == expected);
test(S("12345678901234567890"),
        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>, 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);
   LIBCPP_ASSERT(s.__invariants());
   assert(i - s.begin() == pos);
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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();
   S s0                                 = s;
   if (pos1 <= old_size && pos2 <= sv.size()) {

 #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>, 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) {
     s.insert(pos, str);
     LIBCPP_ASSERT(s.__invariants());
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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;
   if (pos <= old_size) {
     s.insert(pos, str, n);
TEST_CONSTEXPR_CXX20 bool test() {
 
   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>, 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>, 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;
   if (pos <= old_size) {
     s.insert(pos, n, str);
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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) {
     s.insert(pos, str);
     LIBCPP_ASSERT(s.__invariants());
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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 (pos1 <= old_size && pos2 <= str.size()) {
     s.insert(pos1, str, pos2, n);
#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>, 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) {
     s.insert(pos, sv);
     LIBCPP_ASSERT(s.__invariants());
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 'a', S("a"));
   test(S("12345"), 'a', S("12345a"));
   test(S("1234567890"), 'a', S("1234567890a"));
   test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s("123");
   s += {'a', 'b', 'c'};
   assert(s == "123abc");
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  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>, 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> > >();
+  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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s("123def456");
   s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
   assert(s == "123abc456");
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   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;
   typename S::size_type xlen       = last - first;
   s.replace(first, last, f, l);
#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>, 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;
   typename S::size_type xlen       = last - first;
#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>, 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,
#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>, 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,
#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>, 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;
   typename S::size_type xlen       = last - first;
   s.replace(first, last, str);
#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>, 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;
   typename S::size_type xlen       = last - first;
   s.replace(first, last, sv);
#if TEST_STD_VER > 17
   static_assert(test2<S, SV>());
 #endif
 }
 
 int main(int, char**) {
   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,
#if TEST_STD_VER > 17
   static_assert(test55<S, SV>());
 #endif
 }
 
 int main(int, char**) {
   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_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;
   if (pos <= old_size) {
     s.replace(pos, n1, str);

 #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> > >();
 #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,
#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>, 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,
#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>, 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) {
     s.replace(pos1, n1, str);
     LIBCPP_ASSERT(s.__invariants());
#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>, 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,
#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>, 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) {
     s.replace(pos1, n1, sv);
     LIBCPP_ASSERT(s.__invariants());
#if TEST_STD_VER > 17
   static_assert(test2<S, SV>());
 #endif
 }
 
 int main(int, char**) {
   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_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);
   LIBCPP_ASSERT(s1.__invariants());
   LIBCPP_ASSERT(s2.__invariants());
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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.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"
 
 template <template <class> class Alloc>
 void test_string() {
   {
     using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
     std::istringstream in(" abc\n  def\n   ghij");
     S s("initial text");
     std::getline(in, s);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   }
 #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::basic_stringbuf<char> sb("hello");
     std::basic_istream<char> is(&sb);
     is.exceptions(std::ios_base::eofbit);
 
     std::basic_string<char> s;

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"
 
 template <template <class> class Alloc>
 void test_string() {
   {
     using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
     std::istringstream in(" abc*  def**   ghij");
     S s("initial text");
     std::getline(in, s, '*');
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   }
 #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::basic_stringbuf<char> sb("hello");
     std::basic_istream<char> is(&sb);
     is.exceptions(std::ios::eofbit);
 
     std::basic_string<char> s;

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"
 
 template <template <class> class Alloc>
 void test() {
   {
     using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
     S s("initial text");
     std::getline(std::istringstream(" abc*  def*   ghij"), s, '*');
     assert(s == " abc");
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
     WS s(L"initial text");
     std::getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
     assert(s == L" abc");
   }
 #endif
 }
 
 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"
 
 template <template <class> class Alloc>
 void test() {
   {
     using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
     S s("initial text");
     std::getline(std::istringstream(" abc\n  def\n   ghij"), s);
     assert(s == " abc");
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     using WS = std::basic_string<wchar_t, std::char_traits<wchar_t>, Alloc<wchar_t> >;
     WS s(L"initial text");
     std::getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
     assert(s == L" abc");
   }
 #endif
 }
 
 int main(int, char**) {
   test<std::allocator>();
   test<min_allocator>();
+#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"
 
 template <template <class> class Alloc>
 void test_string() {
   {
     using S = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
     std::istringstream in("a bc defghij");
     S s("initial text");
     in >> s;
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   }
 #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;

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"
 
 template <template <class> class Alloc>
 void test() {
   using S  = std::basic_string<char, std::char_traits<char>, Alloc<char> >;
   using OS = std::basic_ostringstream<char, std::char_traits<char>, Alloc<char> >;
   {
     OS out;
     S s("some text");

 #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());
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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

 // 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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+/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>
#if TEST_STD_VER >= 11
   test1('a', S("12345678901234567890"), S("a12345678901234567890"));
 #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+/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>
#if TEST_STD_VER >= 11
   test1("abcdefghijklmnopqrst", S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 #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_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>
#if TEST_STD_VER >= 11
   test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
 #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>
#if TEST_STD_VER >= 11
   test1(S("abcdefghijklmnopqrst"), "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
 #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_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>
#if TEST_STD_VER >= 11
   test3(S("abcdefghijklmnopqrst"), S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 #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_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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test("abcdefghijklmnopqrst", S("abcdefghij"), false);
   test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
 }
 
 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==/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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
   test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
 }
 
 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==/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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
   test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   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>, 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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
   test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test("abcdefghijklmnopqrst", S("abcdefghij"), true);
   test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
 }
 
 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_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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
   test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
 }
 
 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_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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), true);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), true);
   test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test("abcdefghijklmnopqrst", S("abcdefghij"), false);
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
   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>, 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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
   test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test("abcdefghijklmnopqrst", S("abcdefghij"), false);
   test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
 }
 
 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_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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
   test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
 }
 
 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_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);
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), false);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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);
 }
 
 template <class CharT, template <class> class Alloc>
 TEST_CONSTEXPR_CXX20 void test_string() {
TEST_CONSTEXPR_CXX20 void test_string() {
   test(SV("abcdefghijklmnopqrst"), S("abcdefghij"), false);
   test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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()));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(""));
   test(S("abcde"));
   test(S("abcdefghij"));
   test(S("abcdefghijklmnopqrst"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   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) {
     assert(T::compare(str, &s[0], s.size()) == 0);
     assert(T::eq(str[s.size()], typename S::value_type()));
#if TEST_STD_VER > 14
   }
 #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.ops/string.accessors/get_allocator.pass.cpp

TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   test(S("abcdefghijklmnopqrst", A(3)), A(3));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
   test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
   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;
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), "abcdefghij", 10);
   test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 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_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)
     return -1;
#if TEST_STD_VER > 17
   static_assert(test56<S, SV>());
 #endif
 }
 
 int main(int, char**) {
   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.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)
     return -1;
TEST_CONSTEXPR_CXX20 void test_string() {
   test1<S>();
   test2<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>, 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)
     return -1;
#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>, 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;
 }
#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>, fancy_pointer_allocator<char> > >();
   { // LWG 2946
     std::string s = " !";
     assert(s.compare(0, 1, {"abc", 1}) < 0);
   }
 #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)
     return -1;
#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>, 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)
     return -1;
TEST_CONSTEXPR_CXX20 void test_string() {
   test1<S, SV>();
   test2<S, SV>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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;
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), S("abcdefghij"), 10);
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), 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> > >();
   { // 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;
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcdefghijklmnopqrst"), SV("abcdefghij"), 10);
   test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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());
TEST_CONSTEXPR_CXX20 void test_string() {
   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);
   if (x != S::npos)
     assert(pos <= x && x < s.size());
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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) {
TEST_CONSTEXPR_CXX20 void test_string() {
   test2<S>();
   test3<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>, 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)
     assert(pos <= x && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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)
     assert(pos <= x && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S, SV>();
   test1<S, SV>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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());
TEST_CONSTEXPR_CXX20 void test_string() {
   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);
   if (x != S::npos)
     assert(pos <= x && x < s.size());
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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) {
TEST_CONSTEXPR_CXX20 void test_string() {
   test2<S>();
   test3<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>, 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)
     assert(pos <= x && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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)
     assert(pos <= x && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S, SV>();
   test1<S, SV>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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());
TEST_CONSTEXPR_CXX20 void test_string() {
   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);
   if (x != S::npos)
     assert(x <= pos && x < s.size());
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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) {
TEST_CONSTEXPR_CXX20 void test_string() {
   test2<S>();
   test3<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>, 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)
     assert(x <= pos && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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)
     assert(x <= pos && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S, SV>();
   test1<S, SV>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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());
TEST_CONSTEXPR_CXX20 void test_string() {
   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);
   if (x != S::npos)
     assert(x <= pos && x < s.size());
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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) {
TEST_CONSTEXPR_CXX20 void test_string() {
   test2<S>();
   test3<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>, 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)
     assert(x <= pos && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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)
     assert(x <= pos && x < s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S, SV>();
   test1<S, SV>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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());
TEST_CONSTEXPR_CXX20 void test_string() {
   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);
   if (x != S::npos) {
     typename S::size_type n = S::traits_type::length(str);
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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) {
TEST_CONSTEXPR_CXX20 void test_string() {
   test2<S>();
   test3<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>, 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)
     assert(pos <= x && x + str.size() <= s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, fancy_pointer_allocator<char> > >();
 #endif
 #if TEST_STD_VER >= 11
   { // LWG 2946
     std::string s = " !";
     assert(s.find({"abc", 1}) == std::string::npos);
   }
 #endif
 

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)
     assert(pos <= x && x + sv.size() <= s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S, SV>();
   test1<S, SV>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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());
TEST_CONSTEXPR_CXX20 void test_string() {
   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);
   if (x != S::npos) {
     typename S::size_type n = S::traits_type::length(str);
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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) {
TEST_CONSTEXPR_CXX20 void test_string() {
   test2<S>();
   test3<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>, 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)
     assert(x <= pos && x + str.size() <= s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S>();
   test1<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>, 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)
     assert(x <= pos && x + sv.size() <= s.size());
 }
TEST_CONSTEXPR_CXX20 void test_string() {
   test0<S, SV>();
   test1<S, SV>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
 #if TEST_STD_VER >= 11
   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_allocator.h"
 #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);
     LIBCPP_ASSERT(str.__invariants());
     assert(pos <= s.size());
     typename S::size_type rlen = std::min(n, s.size() - pos);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("lsaijeqhtrbgcdmpfkno"), 20, 0);
   test(S("dplqartnfgejichmoskb"), 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>, fancy_pointer_allocator<char> > >();
 #endif
 
   return true;
 }
 
 TEST_CONSTEXPR_CXX20 bool test_alloc() {
   {
     using alloc  = test_allocator<char>;

libcxx/test/std/strings/basic.string/string.ops/string_substr/substr_rvalue.pass.cpp

constexpr void test_string() {
   test<S>(STR("long long string so no SSO"), 27, 0, should_throw_exception);
 }
 
 template <class CharT, class CharTraits>
 constexpr void test_allocators() {
   test_string<std::basic_string<CharT, CharTraits, std::allocator<CharT>>>();
   test_string<std::basic_string<CharT, CharTraits, min_allocator<CharT>>>();
   test_string<std::basic_string<CharT, CharTraits, test_allocator<CharT>>>();
+  test_string<std::basic_string<CharT, CharTraits, fancy_pointer_allocator<CharT>>>();
 }
 
 template <class CharT>
 constexpr void test_char_traits() {
   test_allocators<CharT, std::char_traits<CharT>>();
   test_allocators<CharT, constexpr_char_traits<CharT>>();
 }
 

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

TEST_CONSTEXPR_CXX20 void test_string<char, test_allocator>() {
   test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<char, std::allocator>();
   test_string<char, test_allocator>();
 #if TEST_STD_VER >= 11
   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"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s1{};
   S s2{"abcde", 5};
 
   ASSERT_NOEXCEPT(s1.starts_with('e'));
 
   assert(!s1.starts_with('a'));
   assert(!s1.starts_with('x'));
   assert(s2.starts_with('a'));
   assert(!s2.starts_with('x'));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
+  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.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"
 
 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 };
TEST_CONSTEXPR_CXX20 void test_string() {
   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>();
+  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.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"
 
 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;
TEST_CONSTEXPR_CXX20 void test_string() {
   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>();
+  test_string<char, fancy_pointer_allocator>();
 
   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), "");
   static_assert((std::is_same<typename S::value_type, typename Traits::char_type>::value), "");
   static_assert((std::is_same<typename S::value_type, typename Allocator::value_type>::value), "");
int main(int, char**) {
   test<test_traits<char>, test_allocator<char> >();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<std::char_traits<wchar_t>, std::allocator<wchar_t> >();
 #endif
   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(), S("aba"), 0);
   test0(S("aba"), opt('a'), S("b"), 2);
   test0(S("aba"), opt('b'), S("aa"), 1);
   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>, 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("aaa"), isB, S("aaa"), 0);
 
   test0(S("aba"), False, S("aba"), 0);
   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>, 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);
 }
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: