[libc++] Make test_allocator constexpr-friendly for constexpr string/vector

[philnik]

Summary

Make test_allocator etc. constexpr-friendly so they can be used to test constexpr string and possibly constexpr vector

[• Quuxplusone]

I don't believe this gets us all the way to constexpr-friendliness yet; see my comments and please let me know if anything I said fails to make sense. :)

libcxx/test/support/test_allocator.h

67

You've correctly intuited about half of the fix I intended. :) So this is a step in the right direction, but you need to take one more step before it'll fix the constexprness problem.
The next step is to get rid of the global ::alloc_stats. Instead, each caller is going to do something like (e.g. in move_alloc.pass.cpp)

    test_allocator_statistics alloc_stats;  // LOCAL VARIABLE
    {
    typedef test_allocator<char> A;
    typedef std::basic_string<char, std::char_traits<char>, A> S;
#if TEST_STD_VER > 14
    static_assert((noexcept(S{})), "" );
#elif TEST_STD_VER >= 11
    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "");
#endif
    S s1("Twas brillig, and the slivy toves did gyre and gymbal in the wabe");
    S s2(std::move(s1), A(1, &alloc_stats));  // DIFFERENCE HERE
    }
    assert(alloc_stats.alloc_count == alloc_count);

And then this test will be trivially constexpr-ible, because it won't depend on any global runtime state.

I'm assuming that as part of this transformation, the test_alloc_base class will actually go away, because now it doesn't really serve any purpose. But maybe I'm missing something.

98–99

This ctor overload set will become more like

test_allocator_statistics *stats_ = nullptr;
int data_ = 0;  // participates in equality
int id_ = 0;  // unique identifier, doesn't participate in equality
~~~
explicit test_allocator() = default;
TEST_CONSTEXPR explicit test_allocator(int data) TEST_NOEXCEPT :
    data_(data) {}
TEST_CONSTEXPR explicit test_allocator(int data, int id) TEST_NOEXCEPT :
    data_(data), id_(id) {}
TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, test_allocator_statistics *stats) TEST_NOEXCEPT :
    stats_(stats), data_(data) { stats_->count += 1; }
TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator& a) TEST_NOEXCEPT :
    stats_(a.stats), data_(a.data), id_(a.id_)
{
    if (stats_ != nullptr) {
        stats_->count += 1;
        stats_->copied += 1;
    }
    assert(a.data_ != destructed_value && a.id_ != destructed_value && "copying from destroyed allocator");
}

and so on. (Notice that it's OK to use NSDMIs and =default in C++03 mode, because Clang supports them as extensions, and we don't claim to support any non-Clang compilers prior to C++11 mode.)
Also notice that I'm drive-by applying my general guidelines of "one signature, one declaration" — default arguments are the devil — and "mark all ctors explicit except for copy and move ctors"; and applying my specific aforementioned guideline of "use the most aggressive constexpr macros possible, in test/support code."

[philnik]

Defaulting now to nullptr

[philnik]

I know you don't like clang-format, but (to me) the formatting in test_allocator.h felt like a complete clusterfuck. Maybe it's just me, but I edited large parts of the file anyways.

libcxx/test/support/test_allocator.h

502

Is there any reason the copy ctor isn't really marked = delete?

[philnik]

Replaced assert(data_ >= 0) with assert(data_ != destructed_value)
Made the special values constexpr and removed default_value because it was unused

[philnik]

Didn't upload all stuff

[jloser]

libcxx/test/support/test_allocator.h

502

FYI I changed this in https://reviews.llvm.org/D111148

[• Quuxplusone]

At this point I'm happy, modulo some last formatting/naming comments. Of course assuming that (1) buildkite is happy, and (2) you've tested rebasing your constexpr string PR on top of this and confirmed that it does successfully do all you need in order to make those string-allocator tests constexpr-friendly.
Leaving it to @ldionne or @Mordante to give libc++ approval.

libcxx/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp

63

This change is mildly gross, but I think I agree that it has no ill effect on what this test is trying to test.

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

22

For this string test in particular: Are you confident that the step from this point, to TEST_CONSTEXPR_CXX20, is a small step that "just works"?
The step should be just

• Move alloc_stats into a local variable of test()
• Mark test() as TEST_CONSTEXPR_CXX20 and have it return bool
• static_assert on it

But you should try it locally and make sure we haven't missed anything.

libcxx/test/support/test_allocator.h

54–58

I think having a global variable named moved_value makes it kind of confusing at the call-site — looks too much like it might be a local variable or something. Doesn't look "global enough."
I suggest we actually keep test_alloc_base for now (but not as a base class) — not because it's a good name, but just so that the diff becomes smaller. Right now, you're touching some files only to rename test_alloc_base::moved_value into moved_value, so by keeping the class around, we can remove those files from the diff.

struct test_alloc_base {
    TEST_CONSTEXPR const int destructed_value = -1;
    TEST_CONSTEXPR const int moved_value = INT_MAX;
};

118–120

And likewise throughout. There's nothing wrong with using clang-format as the starting point for your new code, but let's not just replace one clusterfrak with another. ;)

325–327

From here down, you didn't change anything except whitespace, right?
Can you revert all the diffs from here down?

502

This is now D111148.

[Mordante]

A few small nits, but I want to have a closer look when I have more time, unless Louis beats me to it.
Can you make sure you mark all comments done as done?

libcxx/test/support/test_allocator.h

101

Nit: Only a part of the constructors is explicit; please make all appropriate ones explicit.

108

Nit: Please make TEST_NOEXCEPT.

[philnik]

• Moved destructed_value and moved_value back in test_alloc_base and made other_allocator constexpr(needed for constexpr string)
• Merge branch 'main' of https://github.com/llvm/llvm-project

[philnik]

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

22

I merged the two and it works now with the current PR.

libcxx/test/support/test_allocator.h

326–327

I know this is another PR, but maybe other_allocator should be renamed to not_noexcept_allocator or something similar?

[philnik]

rebased

[philnik]

• added test_allocator_statistics to allocate_shared.pass.cpp

[ldionne]

There is some overlap with D68365 (let's move forward with this patch and I can rebase onto it). You might want to take a look at what I did in D68365 in case that gives you ideas. I also think we'll want to pick parts of D68365 out (like the shared_ptr emulation).

libcxx/test/support/test_allocator.h

214–254

Based on what I did in D68365, I think the correct definition of this would be:

#if TEST_STD_VER < 11
    void construct(pointer p, const T& val) {
        ::new(static_cast<void*>(p)) T(val);
    }
#elif TEST_STD_VER < 20
    template <class U>
    void construct(pointer p, U&& val) {
        ::new(static_cast<void*>(p)) T(std::forward<U>(val));
    }
#else
    template <class U>
    constexpr void construct(pointer p, U&& val) {
        std::construct_at(p, std::forward<U>(val));
    }
#endif

[philnik]

• Made the rest of test_allocator.h constexpr

[philnik]

libcxx/test/support/test_allocator.h

214–254

I think it can just be removed, since it doesn't ever get used anyways and is removed in C++20 from std::allocator.

[ldionne]

Roughly LGTM, but I'd really like to avoid making orthogonal changes in this patch. As it stands, this is basically a complete rewrite of test_allocator.h, not just "making the test allocators constexpr friendly".

In libc++, we generally try to make orthogonal changes in separate patches because it makes it easier to validate correctness. I'm sorry for requesting that - I know it means more work for something that you might not see value in since you wrote the patch, but for reviewers it really helps.

libcxx/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp

24

While we're at it, can we avoid making these allocation stats global? We could define the stats as local variables in the functions.

libcxx/test/support/test_allocator.h

69

Please avoid making wide formatting changes in this patch.

I much prefer the way you have it right now, but mixing it with the patch to constexpr-ify these classes makes it a lot harder to validate this patch. Please split off the formatting in a separate patch -- I don't care if it comes before or after.

214–254

Please perform that removal in a separate patch.

[philnik]

Factored out formatting to D112219

[philnik]

Again didn't upload all

[philnik]

Next try...

[philnik]

Ok, now it should be correct

[ldionne]

libcxx/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp

24

Gentle ping on this comment.

[philnik]

• Made test_allocator_statistics local

[ldionne]

Please rebase onto main, that should give you a green CI run.

[philnik]

Rebased

[philnik]

• moved test_allocator_statistics

[philnik]

Someone needs to commit this patch for me. "Nikolas Klauser" <[e-mail]>

[philnik]

Rebased

libcxx/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp

 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 void test_basic() {
   {
     typedef std::pair<const int, double> V;
     std::map<int, double> m =
                             {
                                 {20, 1},
                             };
     m =
void test_basic() {
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 }
 
 
 void duplicate_keys_test() {
   typedef std::map<int, int, std::less<int>, test_allocator<std::pair<const int, int> > > Map;
   {
-    LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
-    Map s = {{1, 0}, {2, 0}, {3, 0}};
-    LIBCPP_ASSERT(test_alloc_base::alloc_count == 3);
+    LIBCPP_ASSERT(alloc_stats.alloc_count == 0);
+    Map s({{1, 0}, {2, 0}, {3, 0}}, std::less<int>(), test_allocator<std::pair<const int, int> >(&alloc_stats));
+    LIBCPP_ASSERT(alloc_stats.alloc_count == 3);
     s = {{4, 0}, {4, 0}, {4, 0}, {4, 0}};
-    LIBCPP_ASSERT(test_alloc_base::alloc_count == 1);
+    LIBCPP_ASSERT(alloc_stats.alloc_count == 1);
     assert(s.size() == 1);
     assert(s.begin()->first == 4);
   }
-  LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
+  LIBCPP_ASSERT(alloc_stats.alloc_count == 0);
 }
 
 int main(int, char**)
 {
   test_basic();
   duplicate_keys_test();
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp

 
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 void basic_test() {
   {
     typedef std::set<int> C;
     typedef C::value_type V;
     C m = {10, 8};
     m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
     assert(distance(m.begin(), m.end()) == 6);
void basic_test() {
     assert(*++i == V(5));
     assert(*++i == V(6));
   }
 }
 
 void duplicate_keys_test() {
   typedef std::set<int, std::less<int>, test_allocator<int> > Set;
   {
-    LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
-    Set s = {1, 2, 3};
-    LIBCPP_ASSERT(test_alloc_base::alloc_count == 3);
+    LIBCPP_ASSERT(alloc_stats.alloc_count == 0);
+    Set s({1, 2, 3}, std::less<int>(), test_allocator<int>(&alloc_stats));
+    LIBCPP_ASSERT(alloc_stats.alloc_count == 3);
     s = {4, 4, 4, 4, 4};
-    LIBCPP_ASSERT(test_alloc_base::alloc_count == 1);
+    LIBCPP_ASSERT(alloc_stats.alloc_count == 1);
     assert(s.size() == 1);
     assert(*s.begin() == 4);
   }
-  LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
+  LIBCPP_ASSERT(alloc_stats.alloc_count == 0);
 }
 
 int main(int, char**) {
   basic_test();
   duplicate_keys_test();
 
   return 0;
 }

libcxx/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp

 #include <set>
 #include <map>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 template <class C>
 void test(int expected_num_allocs = 1) {
   {
-    test_alloc_base::clear();
+    alloc_stats.clear();
     using AllocT = typename C::allocator_type;
-    C v(AllocT(42, 101));
+    C v(AllocT(42, 101, &alloc_stats));
 
-    assert(test_alloc_base::count == expected_num_allocs);
+    assert(alloc_stats.count == expected_num_allocs);
 
-    const int num_stored_allocs = test_alloc_base::count;
+    const int num_stored_allocs = alloc_stats.count;
     {
       const AllocT& a = v.get_allocator();
-      assert(test_alloc_base::count == 1 + num_stored_allocs);
+      assert(alloc_stats.count == 1 + num_stored_allocs);
       assert(a.get_data() == 42);
       assert(a.get_id() == 101);
     }
-    assert(test_alloc_base::count == num_stored_allocs);
-    test_alloc_base::clear_ctor_counters();
+    assert(alloc_stats.count == num_stored_allocs);
+    alloc_stats.clear_ctor_counters();
 
     C v2 = std::move(v);
-    assert(test_alloc_base::count == num_stored_allocs * 2);
-    assert(test_alloc_base::copied == 0);
-    assert(test_alloc_base::moved == num_stored_allocs);
+    assert(alloc_stats.count == num_stored_allocs * 2);
+    assert(alloc_stats.copied == 0);
+    assert(alloc_stats.moved == num_stored_allocs);
     {
       const AllocT& a = v.get_allocator();
       assert(a.get_id() == test_alloc_base::moved_value);
       assert(a.get_data() == test_alloc_base::moved_value);
     }
     {
       const AllocT& a = v2.get_allocator();
       assert(a.get_id() == 101);

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp

 
 // void push_back(const value_type& x);
 
 #include <deque>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include <cassert>
 
+test_allocator_statistics alloc_stats;
+
 // Flag that makes the copy constructor for CMyClass throw an exception
 static bool gCopyConstructorShouldThow = false;
 
 class CMyClass {
     public: CMyClass(int tag);
     public: CMyClass(const CMyClass& iOther);
     public: ~CMyClass();
 
int main(int, char**)
     catch (...) {
         gCopyConstructorShouldThow = false;
         assert(vec==vec2);
     }
     }
 
     {
     typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
-    C vec;
-    C vec2(vec);
+    C vec((test_allocator<CMyClass>(&alloc_stats)));
+    C vec2(vec, test_allocator<CMyClass>(&alloc_stats));
 
-    C::allocator_type::throw_after = 1;
+    alloc_stats.throw_after = 1;
     try {
         vec.push_back(instance);
         assert(false);
     }
     catch (...) {
         assert(vec==vec2);
     }
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp

 
 // void push_front(const value_type& x);
 
 #include <deque>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 // Flag that makes the copy constructor for CMyClass throw an exception
 static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {
     public: CMyClass(int tag);
     public: CMyClass(const CMyClass& iOther);
     public: ~CMyClass();
int main(int, char**)
     catch (...) {
         gCopyConstructorShouldThow = false;
         assert(vec==vec2);
     }
     }
 
     {
     typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
-    C vec;
-    C vec2(vec);
+    C vec((test_allocator<CMyClass>(&alloc_stats)));
+    C vec2(vec, test_allocator<CMyClass>(&alloc_stats));
 
-    C::allocator_type::throw_after = 1;
+    alloc_stats.throw_after = 1;
     try {
         vec.push_front(instance);
         assert(false);
     }
     catch (...) {
         assert(vec==vec2);
     }
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/move.pass.cpp

 // vector(vector&& c);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
     {
-        std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
-        std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5));
+        std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5, &alloc_stats));
+        std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5, &alloc_stats));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(true);
             lo.push_back(true);
         }
         std::vector<bool, test_allocator<bool> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
int main(int, char**)
             lo.push_back(true);
         }
         std::vector<bool, min_allocator<bool> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
     {
-      test_alloc_base::clear();
+      alloc_stats.clear();
       using Vect = std::vector<bool, test_allocator<bool> >;
       using AllocT = Vect::allocator_type;
-      Vect v(test_allocator<bool>(42, 101));
-      assert(test_alloc_base::count == 1);
+      Vect v(test_allocator<bool>(42, 101, &alloc_stats));
+      assert(alloc_stats.count == 1);
       {
         const AllocT& a = v.get_allocator();
-        assert(test_alloc_base::count == 2);
+        assert(alloc_stats.count == 2);
         assert(a.get_data() == 42);
         assert(a.get_id() == 101);
       }
-      assert(test_alloc_base::count == 1);
-      test_alloc_base::clear_ctor_counters();
+      assert(alloc_stats.count == 1);
+      alloc_stats.clear_ctor_counters();
 
       Vect v2 = std::move(v);
-      assert(test_alloc_base::count == 2);
-      assert(test_alloc_base::copied == 0);
-      assert(test_alloc_base::moved == 1);
+      assert(alloc_stats.count == 2);
+      assert(alloc_stats.copied == 0);
+      assert(alloc_stats.moved == 1);
       {
         const AllocT& a = v.get_allocator();
         assert(a.get_id() == test_alloc_base::moved_value);
         assert(a.get_data() == test_alloc_base::moved_value);
       }
       {
         const AllocT& a = v2.get_allocator();
         assert(a.get_id() == 101);
         assert(a.get_data() == 42);
       }
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/move.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
     {
-        std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
-        std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5));
+        std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5, &alloc_stats));
+        std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5, &alloc_stats));
         assert(is_contiguous_container_asan_correct(l));
         assert(is_contiguous_container_asan_correct(lo));
         for (int i = 1; i <= 3; ++i)
         {
             l.push_back(i);
             lo.push_back(i);
         }
         assert(is_contiguous_container_asan_correct(l));
int main(int, char**)
         std::vector<int, min_allocator<int>>::const_iterator i = c1.begin();
         std::vector<int, min_allocator<int>> c2 = std::move(c1);
         assert(is_contiguous_container_asan_correct(c2));
         std::vector<int, min_allocator<int>>::iterator j = c2.erase(i);
         assert(*j == 3);
         assert(is_contiguous_container_asan_correct(c2));
     }
     {
-      test_alloc_base::clear();
+      alloc_stats.clear();
       using Vect = std::vector<int, test_allocator<int> >;
-      Vect v(test_allocator<int>(42, 101));
-      assert(test_alloc_base::count == 1);
-      assert(test_alloc_base::copied == 1);
-      assert(test_alloc_base::moved == 0);
+      Vect v(test_allocator<int>(42, 101, &alloc_stats));
+      assert(alloc_stats.count == 1);
+      assert(alloc_stats.copied == 1);
+      assert(alloc_stats.moved == 0);
       {
         const test_allocator<int>& a = v.get_allocator();
         assert(a.get_data() == 42);
         assert(a.get_id() == 101);
       }
-      assert(test_alloc_base::count == 1);
-      test_alloc_base::clear_ctor_counters();
+      assert(alloc_stats.count == 1);
+      alloc_stats.clear_ctor_counters();
 
       Vect v2 = std::move(v);
-      assert(test_alloc_base::count == 2);
-      assert(test_alloc_base::copied == 0);
-      assert(test_alloc_base::moved == 1);
+      assert(alloc_stats.count == 2);
+      assert(alloc_stats.copied == 0);
+      assert(alloc_stats.moved == 1);
       {
         const test_allocator<int>& a = v.get_allocator();
         assert(a.get_id() == test_alloc_base::moved_value);
         assert(a.get_data() == test_alloc_base::moved_value);
       }
       {
         const test_allocator<int>& a = v2.get_allocator();
         assert(a.get_id() == 101);
         assert(a.get_data() == 42);
       }
     }
 
   return 0;
 }

libcxx/test/std/re/re.results/re.results.const/move.pass.cpp

 //
 //  Additionally, the stored Allocator value is move constructed from m.get_allocator().
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 template <class CharT, class Allocator>
 void
 test(const Allocator& a)
 {
     typedef std::match_results<const CharT*, Allocator> SM;
     ASSERT_NOEXCEPT(SM(std::declval<SM&&>()));
 
     SM m0(a);
     assert(m0.get_allocator() == a);
 
     SM m1(std::move(m0));
     assert(m1.size() == 0);
     assert(!m1.ready());
     assert(m1.get_allocator() == a);
 }
 
 int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
 #endif
 
-    test<char>   (test_allocator<std::sub_match<const char*> >(3));
-    assert(test_alloc_base::moved == 1);
+    test<char>   (test_allocator<std::sub_match<const char*> >(3, &alloc_stats));
+    assert(alloc_stats.moved == 1);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
-    assert(test_alloc_base::moved == 2);
+    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3, &alloc_stats));
+    assert(alloc_stats.moved == 2);
 #endif
 
   return 0;
 }

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

 #include <string>
 #include <cassert>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
+test_allocator_statistics alloc_stats;
+
 template <class S>
 void
 test(S s)
 {
-    S::allocator_type::throw_after = 0;
+    alloc_stats.throw_after = 0;
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
 #endif
     {
         while (s.size() < s.capacity())
             s.push_back(typename S::value_type());
         assert(s.size() == s.capacity());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     catch (...)
     {
         assert(false);
     }
 #endif
-    S::allocator_type::throw_after = INT_MAX;
+    alloc_stats.throw_after = INT_MAX;
 }
 
 int main(int, char**)
 {
     {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
-    S s;
+    S s((test_allocator<char>(&alloc_stats)));
     test(s);
     s.assign(10, 'a');
     s.erase(5);
     test(s);
     s.assign(100, 'a');
     s.erase(50);
     test(s);
     }

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+test_allocator_statistics alloc_stats;
 
 template <class S>
 void
 test(S s0, const typename S::allocator_type& a)
 {
     S s1 = s0;
     S s2(std::move(s0), a);
     LIBCPP_ASSERT(s2.__invariants());
int main(int, char**)
     {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
-    test(S(), A(3));
-    test(S("1"), A(5));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
+    test(S(), A(3, &alloc_stats));
+    test(S("1"), A(5, &alloc_stats));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7, &alloc_stats));
     }
 
-    int alloc_count = test_alloc_base::alloc_count;
+    int alloc_count = alloc_stats.alloc_count;
     {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
-    S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe" );
-    S s2 (std::move(s1), A(1));
+    S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe", A(&alloc_stats));
+    S s2 (std::move(s1), A(1, &alloc_stats));
     }
-    assert ( test_alloc_base::alloc_count == alloc_count );
+    assert ( alloc_stats.alloc_count == alloc_count );
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
     }
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp

 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int> p(std::allocator_arg, test_allocator<int>(42));
-        assert(test_alloc_base::alloc_count == 1);
+        std::promise<int> p(std::allocator_arg, test_allocator<int>(42, &alloc_stats));
+        assert(alloc_stats.alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int&> p(std::allocator_arg, test_allocator<int>(42));
-        assert(test_alloc_base::alloc_count == 1);
+        std::promise<int&> p(std::allocator_arg, test_allocator<int>(42, &alloc_stats));
+        assert(alloc_stats.alloc_count == 1);
         std::future<int&> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<void> p(std::allocator_arg, test_allocator<void>(42));
-        assert(test_alloc_base::alloc_count == 1);
+        std::promise<void> p(std::allocator_arg, test_allocator<void>(42, &alloc_stats));
+        assert(alloc_stats.alloc_count == 1);
         std::future<void> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     // Test with a minimal allocator
     {
         std::promise<int> p(std::allocator_arg, bare_allocator<void>());
         std::future<int> f = p.get_future();
         assert(f.valid());
     }
     {
         std::promise<int&> p(std::allocator_arg, bare_allocator<void>());

libcxx/test/std/thread/futures/futures.promise/move_assign.pass.cpp

 // promise& operator=(promise&& rhs);
 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::alloc_count == 2);
+        std::promise<int> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        std::promise<int> p(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        assert(alloc_stats.alloc_count == 2);
         p = std::move(p0);
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             f = p0.get_future();
             assert(false);
         }
         catch (const std::future_error& e)
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
 #endif
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int&> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int&> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::alloc_count == 2);
+        std::promise<int&> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        std::promise<int&> p(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        assert(alloc_stats.alloc_count == 2);
         p = std::move(p0);
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<int&> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             f = p0.get_future();
             assert(false);
         }
         catch (const std::future_error& e)
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
 #endif
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<void> p0(std::allocator_arg, test_allocator<void>());
-        std::promise<void> p(std::allocator_arg, test_allocator<void>());
-        assert(test_alloc_base::alloc_count == 2);
+        std::promise<void> p0(std::allocator_arg, test_allocator<void>(&alloc_stats));
+        std::promise<void> p(std::allocator_arg, test_allocator<void>(&alloc_stats));
+        assert(alloc_stats.alloc_count == 2);
         p = std::move(p0);
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<void> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             f = p0.get_future();
             assert(false);
         }
         catch (const std::future_error& e)
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
 #endif
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.promise/move_ctor.pass.cpp

 // promise(promise&& rhs);
 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
+        std::promise<int> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
         std::promise<int> p(std::move(p0));
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             f = p0.get_future();
             assert(false);
         }
         catch (const std::future_error& e)
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
 #endif
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int&> p0(std::allocator_arg, test_allocator<int>());
+        std::promise<int&> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
         std::promise<int&> p(std::move(p0));
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<int&> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             f = p0.get_future();
             assert(false);
         }
         catch (const std::future_error& e)
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
 #endif
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<void> p0(std::allocator_arg, test_allocator<void>());
+        std::promise<void> p0(std::allocator_arg, test_allocator<void>(&alloc_stats));
         std::promise<void> p(std::move(p0));
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<void> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             f = p0.get_future();
             assert(false);
         }
         catch (const std::future_error& e)
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
 #endif
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.promise/swap.pass.cpp

 // template <class R> void swap(promise<R>& x, promise<R>& y);
 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::alloc_count == 2);
+        std::promise<int> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        std::promise<int> p(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        assert(alloc_stats.alloc_count == 2);
         p.swap(p0);
-        assert(test_alloc_base::alloc_count == 2);
+        assert(alloc_stats.alloc_count == 2);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 2);
+        assert(alloc_stats.alloc_count == 2);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::alloc_count == 2);
+        assert(alloc_stats.alloc_count == 2);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::alloc_count == 2);
+        std::promise<int> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        std::promise<int> p(std::allocator_arg, test_allocator<int>(&alloc_stats));
+        assert(alloc_stats.alloc_count == 2);
         swap(p, p0);
-        assert(test_alloc_base::alloc_count == 2);
+        assert(alloc_stats.alloc_count == 2);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 2);
+        assert(alloc_stats.alloc_count == 2);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::alloc_count == 2);
+        assert(alloc_stats.alloc_count == 2);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
+        std::promise<int> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
         std::promise<int> p;
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         p.swap(p0);
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
+        std::promise<int> p0(std::allocator_arg, test_allocator<int>(&alloc_stats));
         std::promise<int> p;
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         swap(p, p0);
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.shared_future/dtor.pass.cpp

 // ~shared_future();
 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
         typedef int T;
         std::shared_future<T> f;
         {
-            std::promise<T> p(std::allocator_arg, test_allocator<T>());
-            assert(test_alloc_base::alloc_count == 1);
+            std::promise<T> p(std::allocator_arg, test_allocator<T>(&alloc_stats));
+            assert(alloc_stats.alloc_count == 1);
             f = p.get_future();
-            assert(test_alloc_base::alloc_count == 1);
+            assert(alloc_stats.alloc_count == 1);
             assert(f.valid());
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
         typedef int& T;
         std::shared_future<T> f;
         {
-            std::promise<T> p(std::allocator_arg, test_allocator<int>());
-            assert(test_alloc_base::alloc_count == 1);
+            std::promise<T> p(std::allocator_arg, test_allocator<int>(&alloc_stats));
+            assert(alloc_stats.alloc_count == 1);
             f = p.get_future();
-            assert(test_alloc_base::alloc_count == 1);
+            assert(alloc_stats.alloc_count == 1);
             assert(f.valid());
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
         typedef void T;
         std::shared_future<T> f;
         {
-            std::promise<T> p(std::allocator_arg, test_allocator<T>());
-            assert(test_alloc_base::alloc_count == 1);
+            std::promise<T> p(std::allocator_arg, test_allocator<T>(&alloc_stats));
+            assert(alloc_stats.alloc_count == 1);
             f = p.get_future();
-            assert(test_alloc_base::alloc_count == 1);
+            assert(alloc_stats.alloc_count == 1);
             assert(f.valid());
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
 
   return 0;
 }

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp

 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 class A
 {
     long data_;
 
 public:
     static int n_moves;
     static int n_copies;
 
     explicit A(long i) : data_(i) {}
     A(A&& a) : data_(a.data_) {++n_moves; a.data_ = -1;}
     A(const A& a) : data_(a.data_) {++n_copies;}
 
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
 int A::n_moves = 0;
 int A::n_copies = 0;
 
 int func(int i) { return i; }
 
 int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(std::allocator_arg,
-                                                test_allocator<A>(), A(5));
-        assert(test_alloc_base::alloc_count > 0);
+                                                test_allocator<A>(&alloc_stats), A(5));
+        assert(alloc_stats.alloc_count > 0);
         assert(p.valid());
         std::future<double> f = p.get_future();
         p(3, 'a');
         assert(f.get() == 105.0);
         assert(A::n_copies == 0);
         assert(A::n_moves > 0);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     A::n_copies = 0;
     A::n_moves  = 0;
     {
         A a(5);
         std::packaged_task<double(int, char)> p(std::allocator_arg,
-                                                test_allocator<A>(), a);
-        assert(test_alloc_base::alloc_count > 0);
+                                                test_allocator<A>(&alloc_stats), a);
+        assert(alloc_stats.alloc_count > 0);
         assert(p.valid());
         std::future<double> f = p.get_future();
         p(3, 'a');
         assert(f.get() == 105.0);
         assert(A::n_copies > 0);
         assert(A::n_moves >= 0);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     A::n_copies = 0;
     A::n_moves  = 0;
     {
         A a(5);
-        std::packaged_task<int(int)> p(std::allocator_arg, test_allocator<A>(), &func);
-        assert(test_alloc_base::alloc_count > 0);
+        std::packaged_task<int(int)> p(std::allocator_arg, test_allocator<A>(&alloc_stats), &func);
+        assert(alloc_stats.alloc_count > 0);
         assert(p.valid());
         std::future<int> f = p.get_future();
         p(4);
         assert(f.get() == 4);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     A::n_copies = 0;
     A::n_moves  = 0;
     {
         A a(5);
-        std::packaged_task<int(int)> p(std::allocator_arg, test_allocator<A>(), func);
-        assert(test_alloc_base::alloc_count > 0);
+        std::packaged_task<int(int)> p(std::allocator_arg, test_allocator<A>(&alloc_stats), func);
+        assert(alloc_stats.alloc_count > 0);
         assert(p.valid());
         std::future<int> f = p.get_future();
         p(4);
         assert(f.get() == 4);
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     A::n_copies = 0;
     A::n_moves  = 0;
     {
         std::packaged_task<double(int, char)> p(std::allocator_arg,
                                                 bare_allocator<void>(), A(5));
         assert(p.valid());
         std::future<double> f = p.get_future();
         p(3, 'a');

libcxx/test/std/thread/futures/futures.unique_future/dtor.pass.cpp

 // ~future();
 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 int main(int, char**)
 {
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
         typedef int T;
         std::future<T> f;
         {
-            std::promise<T> p(std::allocator_arg, test_allocator<T>());
-            assert(test_alloc_base::alloc_count == 1);
+            std::promise<T> p(std::allocator_arg, test_allocator<T>(&alloc_stats));
+            assert(alloc_stats.alloc_count == 1);
             f = p.get_future();
-            assert(test_alloc_base::alloc_count == 1);
+            assert(alloc_stats.alloc_count == 1);
             assert(f.valid());
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
         typedef int& T;
         std::future<T> f;
         {
-            std::promise<T> p(std::allocator_arg, test_allocator<int>());
-            assert(test_alloc_base::alloc_count == 1);
+            std::promise<T> p(std::allocator_arg, test_allocator<int>(&alloc_stats));
+            assert(alloc_stats.alloc_count == 1);
             f = p.get_future();
-            assert(test_alloc_base::alloc_count == 1);
+            assert(alloc_stats.alloc_count == 1);
             assert(f.valid());
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
         typedef void T;
         std::future<T> f;
         {
-            std::promise<T> p(std::allocator_arg, test_allocator<T>());
-            assert(test_alloc_base::alloc_count == 1);
+            std::promise<T> p(std::allocator_arg, test_allocator<T>(&alloc_stats));
+            assert(alloc_stats.alloc_count == 1);
             f = p.get_future();
-            assert(test_alloc_base::alloc_count == 1);
+            assert(alloc_stats.alloc_count == 1);
             assert(f.valid());
         }
-        assert(test_alloc_base::alloc_count == 1);
+        assert(alloc_stats.alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "count_new.h"
 #include "../function_types.h"
 
+test_allocator_statistics alloc_stats;
 
 #if TEST_STD_VER >= 11
 struct RValueCallable {
     template <class ...Args>
     void operator()(Args&&...) && {}
 };
 struct LValueCallable {
     template <class ...Args>

 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     FuncType* target = &FreeFunction;
     assert(globalMemCounter.checkOutstandingNewEq(0));
     std::function<FuncType> f2(std::allocator_arg, alloc, target);
     // The allocator may not fit in the small object buffer, if we allocated
     // check it was done via the allocator.
-    assert(globalMemCounter.checkOutstandingNewEq(test_alloc_base::alloc_count));
+    assert(globalMemCounter.checkOutstandingNewEq(alloc_stats.alloc_count));
     assert(f2.template target<FuncType*>());
     assert(*f2.template target<FuncType*>() == target);
     assert(f2.template target<FuncType>() == 0);
     assert(f2.template target<DummyClass>() == 0);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }
 
 template <class TargetType, class FuncType, class AllocType>
 void test_MemFunClass(AllocType& alloc)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     TargetType target = &MemFunClass::foo;
     assert(globalMemCounter.checkOutstandingNewEq(0));
     std::function<FuncType> f2(std::allocator_arg, alloc, target);
-    assert(globalMemCounter.checkOutstandingNewEq(test_alloc_base::alloc_count));
+    assert(globalMemCounter.checkOutstandingNewEq(alloc_stats.alloc_count));
     assert(f2.template target<TargetType>());
     assert(*f2.template target<TargetType>() == target);
     assert(f2.template target<FuncType*>() == 0);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }
 
 template <class Alloc>

 int main(int, char**)
 {
   globalMemCounter.reset();
   {
     bare_allocator<DummyClass> bare_alloc;
     test_for_alloc(bare_alloc);
   }
     {
-        non_default_test_allocator<DummyClass> non_default_alloc(42);
+        non_default_test_allocator<DummyClass> non_default_alloc(42, &alloc_stats);
         test_for_alloc(non_default_alloc);
     }
 #if TEST_STD_VER >= 11
     {
         using Fn = std::function<void(int, int, int)>;
         static_assert(std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, LValueCallable&>::value, "");
         static_assert(std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, LValueCallable>::value, "");
         static_assert(!std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, RValueCallable&>::value, "");
         static_assert(!std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, RValueCallable>::value, "");
     }
 #endif
 
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp

 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 struct A
 {
     static int count;
 
     A() {++count;}
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
     {
-    std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5));
+    std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5, &alloc_stats));
     assert(A::count == 0);
     assert(p.use_count() == 1);
     assert(p.get() == 0);
     assert(test_deleter<A>::count == 1);
     assert(test_deleter<A>::dealloc_count == 0);
 #ifndef TEST_HAS_NO_RTTI
     test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
     assert(d);
     assert(d->state() == 3);
 #endif
-    assert(test_allocator<A>::count == 1);
-    assert(test_allocator<A>::alloc_count == 1);
+    assert(alloc_stats.count == 1);
+    assert(alloc_stats.alloc_count == 1);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
-    assert(test_allocator<A>::count == 0);
-    assert(test_allocator<A>::alloc_count == 0);
+    assert(alloc_stats.count == 0);
+    assert(alloc_stats.alloc_count == 0);
     test_deleter<A>::dealloc_count = 0;
     // Test an allocator with a minimal interface
     {
     std::shared_ptr<A> p(nullptr, test_deleter<A>(1), bare_allocator<void>());
     assert(A::count == 0);
     assert(p.use_count() == 1);
     assert(p.get() == 0);
     assert(test_deleter<A>::count ==1);

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp

 // template<class D, class A> shared_ptr(nullptr_t, D d, A a);
 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 struct A
 {
     static int count;
 
     A() {++count;}
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
     try
     {
-        test_allocator<A>::throw_after = 0;
-        std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5));
+        alloc_stats.throw_after = 0;
+        std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5, &alloc_stats));
         assert(false);
     }
     catch (std::bad_alloc&)
     {
         assert(A::count == 0);
         assert(test_deleter<A>::count == 0);
         assert(test_deleter<A>::dealloc_count == 1);
-        assert(test_allocator<A>::count == 0);
-        assert(test_allocator<A>::alloc_count == 0);
+        assert(alloc_stats.count == 0);
+        assert(alloc_stats.alloc_count == 0);
     }
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp

 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 struct A
 {
     static int count;
 
     A() {++count;}
     A(const A&) {++count;}
     ~A() {--count;}
 };
public:
 
     void operator()(T *ptr) { delete ptr; }
 };
 
 int main(int, char**)
 {
     {
     A* ptr = new A;
-    std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5));
+    std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5, &alloc_stats));
     assert(A::count == 1);
     assert(p.use_count() == 1);
     assert(p.get() == ptr);
     assert(test_deleter<A>::count == 1);
     assert(test_deleter<A>::dealloc_count == 0);
 #ifndef TEST_HAS_NO_RTTI
     test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
     assert(d);
     assert(d->state() == 3);
 #endif
-    assert(test_allocator<A>::count == 1);
-    assert(test_allocator<A>::alloc_count == 1);
+    assert(alloc_stats.count == 1);
+    assert(alloc_stats.alloc_count == 1);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
-    assert(test_allocator<A>::count == 0);
-    assert(test_allocator<A>::alloc_count == 0);
+    assert(alloc_stats.count == 0);
+    assert(alloc_stats.alloc_count == 0);
     test_deleter<A>::dealloc_count = 0;
     // Test an allocator with a minimal interface
     {
     A* ptr = new A;
     std::shared_ptr<A> p(ptr, test_deleter<A>(3), bare_allocator<void>());
     assert(A::count == 1);
     assert(p.use_count() == 1);
     assert(p.get() == ptr);

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp

 // template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 struct A
 {
     static int count;
 
     A() {++count;}
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
     A* ptr = new A;
     try
     {
-        test_allocator<A>::throw_after = 0;
-        std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5));
+        alloc_stats.throw_after = 0;
+        std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5, &alloc_stats));
         assert(false);
     }
     catch (std::bad_alloc&)
     {
-        assert(A::count == 0);
-        assert(test_deleter<A>::count == 0);
+        assert(alloc_stats.count == 0);
+        assert(alloc_stats.count == 0);
         assert(test_deleter<A>::dealloc_count == 1);
-        assert(test_allocator<A>::count == 0);
-        assert(test_allocator<A>::alloc_count == 0);
+        assert(alloc_stats.count == 0);
+        assert(alloc_stats.alloc_count == 0);
     }
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp

 #include <new>
 #include <cstdlib>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int new_count = 0;
+test_allocator_statistics alloc_stats;
 
 struct A
 {
     static int count;
 
     A(int i, char c) : int_(i), char_(c) {++count;}
     A(const A& a)
         : int_(a.int_), char_(a.char_)

 int main(int, char**)
 {
     test<bare_allocator<void> >();
     test<test_allocator<void> >();
 
     {
     int i = 67;
     char c = 'e';
-    std::shared_ptr<A> p = std::allocate_shared<A>(test_allocator<A>(54), i, c);
-    assert(test_allocator<A>::alloc_count == 1);
+    std::shared_ptr<A> p = std::allocate_shared<A>(test_allocator<A>(54, &alloc_stats), i, c);
+    assert(alloc_stats.alloc_count == 1);
     assert(A::count == 1);
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');
     }
     assert(A::count == 0);
-    assert(test_allocator<A>::alloc_count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
     int i = 67;
     char c = 'e';
     std::shared_ptr<A> p = std::allocate_shared<A>(min_allocator<void>(), i, c);
     assert(A::count == 1);
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');
     }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp

 // template<class Y, class D, class A> void reset(Y* p, D d, A a);
 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "test_allocator.h"
 
+test_allocator_statistics alloc_stats;
+
 struct B
 {
     static int count;
 
     B() {++count;}
     B(const B&) {++count;}
     virtual ~B() {--count;}
 };

 
 int A::count = 0;
 
 int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
         A* ptr = new A;
-        p.reset(ptr, test_deleter<A>(3), test_allocator<A>(4));
+        p.reset(ptr, test_deleter<A>(3), test_allocator<A>(4, &alloc_stats));
         assert(A::count == 1);
         assert(B::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
         assert(test_deleter<A>::count == 1);
         assert(test_deleter<A>::dealloc_count == 0);
 #ifndef TEST_HAS_NO_RTTI
         test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
         assert(d);
         assert(d->state() == 3);
 #endif
-        assert(test_allocator<A>::count == 1);
-        assert(test_allocator<A>::alloc_count == 1);
+        assert(alloc_stats.count == 1);
+        assert(alloc_stats.alloc_count == 1);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
-    assert(test_allocator<A>::count == 0);
-    assert(test_allocator<A>::alloc_count == 0);
+    assert(alloc_stats.count == 0);
+    assert(alloc_stats.alloc_count == 0);
     {
         std::shared_ptr<B> p;
         A* ptr = new A;
-        p.reset(ptr, test_deleter<A>(3), test_allocator<A>(4));
+        p.reset(ptr, test_deleter<A>(3), test_allocator<A>(4, &alloc_stats));
         assert(A::count == 1);
         assert(B::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
         assert(test_deleter<A>::count == 1);
         assert(test_deleter<A>::dealloc_count == 1);
 #ifndef TEST_HAS_NO_RTTI
         test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
         assert(d);
         assert(d->state() == 3);
 #endif
-        assert(test_allocator<A>::count == 1);
-        assert(test_allocator<A>::alloc_count == 1);
+        assert(alloc_stats.count == 1);
+        assert(alloc_stats.alloc_count == 1);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 2);
-    assert(test_allocator<A>::count == 0);
-    assert(test_allocator<A>::alloc_count == 0);
+    assert(alloc_stats.count == 0);
+    assert(alloc_stats.alloc_count == 0);
 
 #if TEST_STD_VER > 14
     {
         std::shared_ptr<const A[]> p;
         A* ptr = new A[8];
         p.reset(ptr, CDeleter<A[]>(), test_allocator<A[]>());
         assert(A::count == 8);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
     }
     assert(A::count == 0);
 #endif
 
   return 0;
 }

libcxx/test/support/test_allocator.h

 #include <cstddef>
 #include <cstdlib>
 #include <climits>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class Alloc>
-inline typename std::allocator_traits<Alloc>::size_type
-alloc_max_size(Alloc const &a) {
+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);
 }
 
-class test_alloc_base
-{
-protected:
-    static int time_to_throw;
-public:
-    static int throw_after;
-    static int count;
-    static int alloc_count;
-    static int copied;
-    static int moved;
-    static int converted;
-
-    const static int destructed_value = -1;
-    const static int default_value = 0;
-    const static int moved_value = INT_MAX;
+struct test_allocator_statistics {
+  int time_to_throw = 0;
+  int throw_after = INT_MAX;
+  int count = 0;
+  int alloc_count = 0;
+  int copied = 0;
+  int moved = 0;
+  int converted = 0;
 
-    static void clear() {
-      assert(count == 0 && "clearing leaking allocator data?");
-      count = 0;
-      time_to_throw = 0;
-      alloc_count = 0;
-      throw_after = INT_MAX;
-      clear_ctor_counters();
-    }
+  TEST_CONSTEXPR_CXX14 void clear() {
 
-    static void clear_ctor_counters() {
-      copied = 0;
-      moved = 0;
-      converted = 0;
-    }
+  TEST_CONSTEXPR_CXX14 void clear_ctor_counters() {
 };
 
-int test_alloc_base::count = 0;
-int test_alloc_base::time_to_throw = 0;
-int test_alloc_base::alloc_count = 0;
-int test_alloc_base::throw_after = INT_MAX;
-int test_alloc_base::copied = 0;
-int test_alloc_base::moved = 0;
-int test_alloc_base::converted = 0;
+struct test_alloc_base {
+  TEST_CONSTEXPR static const int destructed_value = -1;
+  TEST_CONSTEXPR static const int moved_value = INT_MAX;
+};
 
 template <class T>
-class test_allocator
-    : public test_alloc_base
-{
-    int data_; // participates in equality
-    int id_; // unique identifier, doesn't participate in equality
-    template <class U> friend class test_allocator;
-public:
+class test_allocator {
+  int data_ = 0; // participates in equality
+  int id_ = 0;   // unique identifier, doesn't participate in equality
+  test_allocator_statistics* stats_ = nullptr;
+
+  template <class U>
+  friend class test_allocator;
 
-    typedef unsigned                                                   size_type;
-    typedef int                                                        difference_type;
-    typedef T                                                          value_type;
-    typedef value_type*                                                pointer;
-    typedef const value_type*                                          const_pointer;
-    typedef typename std::add_lvalue_reference<value_type>::type       reference;
-    typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
+public:
+  typedef unsigned size_type;
+  typedef int difference_type;
+  typedef T value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef typename std::add_lvalue_reference<value_type>::type reference;
 
-    template <class U> struct rebind {typedef test_allocator<U> other;};
+  template <class U>
+  struct rebind {
+    typedef test_allocator<U> other;
+  };
+
+  TEST_CONSTEXPR test_allocator() TEST_NOEXCEPT = default;
+
+  TEST_CONSTEXPR_CXX14 explicit test_allocator(test_allocator_statistics* stats) TEST_NOEXCEPT : stats_(stats) {
+    if (stats_ != nullptr)
+      ++stats_->count;
+  }
+
+  TEST_CONSTEXPR explicit test_allocator(int data) TEST_NOEXCEPT : data_(data) {}
+
+  TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, test_allocator_statistics* stats) TEST_NOEXCEPT
+      : data_(data), stats_(stats) {
+    if (stats != nullptr)
+      ++stats_->count;
+  }
+
+  TEST_CONSTEXPR explicit test_allocator(int data, int id) TEST_NOEXCEPT : data_(data), id_(id) {}
 
-    test_allocator() TEST_NOEXCEPT : data_(0), id_(0) {++count;}
-    explicit test_allocator(int i, int id = 0) TEST_NOEXCEPT : data_(i), id_(id)
-      {++count;}
-    test_allocator(const test_allocator& a) TEST_NOEXCEPT : data_(a.data_),
-                                                            id_(a.id_) {
-      ++count;
-      ++copied;
-      assert(a.data_ != destructed_value && a.id_ != destructed_value &&
-             "copying from destroyed allocator");
+  TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, int id, test_allocator_statistics* stats) TEST_NOEXCEPT
+      : data_(data), id_(id), stats_(stats) {
+    if (stats_ != nullptr)
+      ++stats_->count;
+  }
+
+  TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator& a) TEST_NOEXCEPT
+    : data_(a.data_), id_(a.id_), stats_(a.stats_) {
+    assert(a.data_ != test_alloc_base::destructed_value && a.id_ != test_alloc_base::destructed_value &&
+    if (stats_ != nullptr) {
+      ++stats_->count;
+      ++stats_->copied;
     }
+  }
+
 #if TEST_STD_VER >= 11
-    test_allocator(test_allocator&& a) TEST_NOEXCEPT : data_(a.data_),
-                                                       id_(a.id_) {
-      ++count;
-      ++moved;
-      assert(a.data_ != destructed_value && a.id_ != destructed_value &&
-             "moving from destroyed allocator");
-      a.data_ = moved_value;
-      a.id_ = moved_value;
-    }
+  TEST_CONSTEXPR_CXX14 test_allocator(test_allocator&& a) TEST_NOEXCEPT : data_(a.data_), id_(a.id_), stats_(a.stats_) {
+    if (stats_ != nullptr) {
+      ++stats_->count;
+      ++stats_->moved;
+    }
+    assert(a.data_ != test_alloc_base::destructed_value && a.id_ != test_alloc_base::destructed_value &&
+    a.data_ = test_alloc_base::moved_value;
+    a.id_ = test_alloc_base::moved_value;
 #endif
-    template <class U>
-    test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT : data_(a.data_),
-                                                               id_(a.id_) {
-      ++count;
-      ++converted;
-    }
-    ~test_allocator() TEST_NOEXCEPT {
-      assert(data_ >= 0); assert(id_ >= 0);
-      --count;
-      data_ = destructed_value;
-      id_ = destructed_value;
-    }
-    pointer address(reference x) const {return &x;}
-    const_pointer address(const_reference x) const {return &x;}
-    pointer allocate(size_type n, const void* = 0)
-        {
-            assert(data_ >= 0);
-            if (time_to_throw >= throw_after) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-                throw std::bad_alloc();
-#else
-                std::terminate();
-#endif
-            }
-            ++time_to_throw;
-            ++alloc_count;
-            return (pointer)::operator new(n * sizeof(T));
-        }
-    void deallocate(pointer p, size_type)
-        {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p);}
-    size_type max_size() const TEST_NOEXCEPT
-        {return UINT_MAX / sizeof(T);}
+
+  TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_), stats_(a.stats_) {
+    if (stats_ != nullptr) {
+      ++stats_->count;
+      ++stats_->converted;
+    }
+  }
+
+  TEST_CONSTEXPR_CXX20 ~test_allocator() TEST_NOEXCEPT {
+    assert(data_ != test_alloc_base::destructed_value);
+    assert(id_ != test_alloc_base::destructed_value);
+    if (stats_ != nullptr)
+      --stats_->count;
+    data_ = test_alloc_base::destructed_value;
+    id_ = test_alloc_base::destructed_value;
+  }
+
+  TEST_CONSTEXPR pointer address(reference x) const { return &x; }
+  TEST_CONSTEXPR const_pointer address(const_reference x) const { return &x; }
+
+  TEST_CONSTEXPR_CXX14 pointer allocate(size_type n, const void* = 0) {
+    assert(data_ != test_alloc_base::destructed_value);
+    if (stats_ != nullptr) {
+      if (stats_->time_to_throw >= stats_->throw_after)
+        TEST_THROW(std::bad_alloc());
+      ++stats_->time_to_throw;
+      ++stats_->alloc_count;
+    }
+    return std::allocator<value_type>().allocate(n);
+  }
+
+  TEST_CONSTEXPR_CXX14 void deallocate(pointer p, size_type s) {
+    assert(data_ != test_alloc_base::destructed_value);
+    if (stats_ != nullptr)
+      --stats_->alloc_count;
+    std::allocator<value_type>().deallocate(p, s);
+
+  TEST_CONSTEXPR size_type max_size() const TEST_NOEXCEPT { return UINT_MAX / sizeof(T); }
+
 #if TEST_STD_VER < 11
-    void construct(pointer p, const T& val)
-        {::new(static_cast<void*>(p)) T(val);}
+  void construct(pointer p, const T& val) { ::new (static_cast<void*>(p)) T(val); }
 #else
-    template <class U> void construct(pointer p, U&& val)
-        {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
+  template <class U>
+  TEST_CONSTEXPR_CXX14 void construct(pointer p, U&& val) {
+    ::new (static_cast<void*>(p)) T(std::forward<U>(val));
+  }
 #endif
-    void destroy(pointer p)
-        {p->~T();}
-    friend bool operator==(const test_allocator& x, const test_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const test_allocator& x, const test_allocator& y)
-        {return !(x == y);}
+  TEST_CONSTEXPR_CXX14 void destroy(pointer p) { p->~T(); }
+  TEST_CONSTEXPR friend bool operator==(const test_allocator& x, const test_allocator& y) { return x.data_ == y.data_; }
+  TEST_CONSTEXPR friend bool operator!=(const test_allocator& x, const test_allocator& y) { return !(x == y); }
 
-    int get_data() const { return data_; }
-    int get_id() const { return id_; }
+  TEST_CONSTEXPR int get_data() const { return data_; }
+  TEST_CONSTEXPR int get_id() const { return id_; }
 };
 
 template <class T>
-class non_default_test_allocator
-    : public test_alloc_base
-{
-    int data_;
+class non_default_test_allocator {
+  int data_ = 0;
+  test_allocator_statistics* stats_ = nullptr;
 
-    template <class U> friend class non_default_test_allocator;
-public:
+  template <class U>
+  friend class non_default_test_allocator;
 
-    typedef unsigned                                                   size_type;
-    typedef int                                                        difference_type;
-    typedef T                                                          value_type;
-    typedef value_type*                                                pointer;
-    typedef const value_type*                                          const_pointer;
-    typedef typename std::add_lvalue_reference<value_type>::type       reference;
-    typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
+public:
+  typedef unsigned size_type;
+  typedef int difference_type;
+  typedef T value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef typename std::add_lvalue_reference<value_type>::type reference;
 
-    template <class U> struct rebind {typedef non_default_test_allocator<U> other;};
+  template <class U>
+  struct rebind {
+    typedef non_default_test_allocator<U> other;
+  };
 
-//    non_default_test_allocator() TEST_NOEXCEPT : data_(0) {++count;}
-    explicit non_default_test_allocator(int i) TEST_NOEXCEPT : data_(i) {++count;}
-    non_default_test_allocator(const non_default_test_allocator& a) TEST_NOEXCEPT
-        : data_(a.data_) {++count;}
-    template <class U> non_default_test_allocator(const non_default_test_allocator<U>& a) TEST_NOEXCEPT
-        : data_(a.data_) {++count;}
-    ~non_default_test_allocator() TEST_NOEXCEPT {assert(data_ >= 0); --count; data_ = -1;}
-    pointer address(reference x) const {return &x;}
-    const_pointer address(const_reference x) const {return &x;}
-    pointer allocate(size_type n, const void* = 0)
-        {
-            assert(data_ >= 0);
-            if (time_to_throw >= throw_after) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-                throw std::bad_alloc();
-#else
-                std::terminate();
-#endif
-            }
-            ++time_to_throw;
-            ++alloc_count;
-            return (pointer)::operator new (n * sizeof(T));
-        }
-    void deallocate(pointer p, size_type)
-        {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p); }
-    size_type max_size() const TEST_NOEXCEPT
-        {return UINT_MAX / sizeof(T);}
-#if TEST_STD_VER < 11
-    void construct(pointer p, const T& val)
-        {::new(static_cast<void*>(p)) T(val);}
-#else
-    template <class U> void construct(pointer p, U&& val)
-        {::new(static_cast<void*>(p)) T(std::forward<U>(val));}
-#endif
-    void destroy(pointer p) {p->~T();}
+  TEST_CONSTEXPR_CXX14
+  explicit non_default_test_allocator(int i, test_allocator_statistics* stats = nullptr) TEST_NOEXCEPT
+      : data_(i), stats_(stats) {
+    if (stats_ != nullptr) {
+      ++stats_->count;
+  }
+
+  TEST_CONSTEXPR_CXX14
+  non_default_test_allocator(const non_default_test_allocator& a) TEST_NOEXCEPT : data_(a.data_), stats_(a.stats_) {
+    if (stats_ != nullptr)
+      ++stats_->count;
+  }
+
+  template <class U>
+  TEST_CONSTEXPR_CXX14 non_default_test_allocator(const non_default_test_allocator<U>& a) TEST_NOEXCEPT
+      : data_(a.data_), stats_(a.stats_) {
+    if (stats_ != nullptr)
+      ++stats_->count;
+  }
+
+  TEST_CONSTEXPR_CXX20 ~non_default_test_allocator() TEST_NOEXCEPT {
+    assert(data_ != test_alloc_base::destructed_value);
+    if (stats_ != nullptr)
+      --stats_->count;
+    data_ = test_alloc_base::destructed_value;
+  }
+
+  TEST_CONSTEXPR pointer address(reference x) const { return &x; }
+  TEST_CONSTEXPR const_pointer address(const_reference x) const { return &x; }
+
+  TEST_CONSTEXPR_CXX20 pointer allocate(size_type n, const void* = nullptr) {
+    assert(data_ != test_alloc_base::destructed_value);
+    if (stats_ != nullptr) {
+      if (stats_->time_to_throw >= stats_->throw_after)
+        TEST_THROW(std::bad_alloc());
+      ++stats_->time_to_throw;
+      ++stats_->alloc_count;
+    }
+    return std::allocator<value_type>().allocate(n);
+  }
+
+  TEST_CONSTEXPR_CXX20 void deallocate(pointer p, size_type n) {
+    assert(data_ != test_alloc_base::destructed_value);
+    if (stats_ != nullptr)
+      --stats_->alloc_count;
+    std::allocator<value_type>().deallocate(p, n);
+  }
+
+  TEST_CONSTEXPR size_type max_size() const TEST_NOEXCEPT { return UINT_MAX / sizeof(T); }
 
-    friend bool operator==(const non_default_test_allocator& x, const non_default_test_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const non_default_test_allocator& x, const non_default_test_allocator& y)
-        {return !(x == y);}
+  TEST_CONSTEXPR friend bool operator==(const non_default_test_allocator& x, const non_default_test_allocator& y) {
+    return x.data_ == y.data_;
+  }
+
+  TEST_CONSTEXPR friend bool operator!=(const non_default_test_allocator& x, const non_default_test_allocator& y) {
+    return !(x == y);
+  }
 };
 
 template <>
-class test_allocator<void>
-    : public test_alloc_base
-{
-    int data_;
-    int id_;
+class test_allocator<void> {
+  int data_ = 0;
+  int id_ = 0;
+  test_allocator_statistics* stats_ = nullptr;
 
-    template <class U> friend class test_allocator;
-public:
+  template <class U>
+  friend class test_allocator;
 
-    typedef unsigned                                                   size_type;
-    typedef int                                                        difference_type;
-    typedef void                                                       value_type;
-    typedef value_type*                                                pointer;
-    typedef const value_type*                                          const_pointer;
+public:
+  typedef unsigned size_type;
+  typedef int difference_type;
+  typedef void value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
 
-    template <class U> struct rebind {typedef test_allocator<U> other;};
+  template <class U>
+  struct rebind {
+    typedef test_allocator<U> other;
+  };
+
+  TEST_CONSTEXPR test_allocator() TEST_NOEXCEPT = default;
+
+  TEST_CONSTEXPR_CXX14 explicit test_allocator(test_allocator_statistics* stats) TEST_NOEXCEPT : stats_(stats) {}
+
+  TEST_CONSTEXPR explicit test_allocator(int data) TEST_NOEXCEPT : data_(data) {}
 
-    test_allocator() TEST_NOEXCEPT : data_(0), id_(0) {}
-    explicit test_allocator(int i, int id = 0) TEST_NOEXCEPT : data_(i), id_(id) {}
-    test_allocator(const test_allocator& a) TEST_NOEXCEPT
-        : data_(a.data_), id_(a.id_) {}
-    template <class U> test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
-        : data_(a.data_), id_(a.id_) {}
-    ~test_allocator() TEST_NOEXCEPT {data_ = -1; id_ = -1; }
-
-    int get_id() const { return id_; }
-    int get_data() const { return data_; }
-
-    friend bool operator==(const test_allocator& x, const test_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const test_allocator& x, const test_allocator& y)
-        {return !(x == y);}
+  TEST_CONSTEXPR explicit test_allocator(int data, test_allocator_statistics* stats) TEST_NOEXCEPT
+      : data_(data), stats_(stats)
+  {}
+
+  TEST_CONSTEXPR explicit test_allocator(int data, int id) : data_(data), id_(id) {}
+
+  TEST_CONSTEXPR_CXX14 explicit test_allocator(int data, int id, test_allocator_statistics* stats) TEST_NOEXCEPT
+      : data_(data), id_(id), stats_(stats)
+  {}
+
+  TEST_CONSTEXPR_CXX14 explicit test_allocator(const test_allocator& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_), stats_(a.stats_)
+  {}
+
+  template <class U>
+  TEST_CONSTEXPR_CXX14 test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
+      : data_(a.data_), id_(a.id_), stats_(a.stats_)
+  {}
+
+  TEST_CONSTEXPR_CXX20 ~test_allocator() TEST_NOEXCEPT {
+    data_ = test_alloc_base::destructed_value;
+    id_ = test_alloc_base::destructed_value;
+  }
+
+  TEST_CONSTEXPR int get_id() const { return id_; }
+  TEST_CONSTEXPR int get_data() const { return data_; }
+
+  TEST_CONSTEXPR friend bool operator==(const test_allocator& x, const test_allocator& y) { return x.data_ == y.data_; }
+  TEST_CONSTEXPR friend bool operator!=(const test_allocator& x, const test_allocator& y) { return !(x == y); }
 };
 
 template <class T>
-class other_allocator
-{
-    int data_;
+class other_allocator {
+  int data_ = -1;
 
-    template <class U> friend class other_allocator;
+  template <class U>
+  friend class other_allocator;
 
 public:
-    typedef T value_type;
 
-    other_allocator() : data_(-1) {}
-    explicit other_allocator(int i) : data_(i) {}
-    template <class U> other_allocator(const other_allocator<U>& a)
-        : data_(a.data_) {}
-    T* allocate(std::size_t n)
-        {return (T*)::operator new(n * sizeof(T));}
-    void deallocate(T* p, std::size_t)
-        {::operator delete((void*)p);}
-
-    other_allocator select_on_container_copy_construction() const
-        {return other_allocator(-2);}
-
-    friend bool operator==(const other_allocator& x, const other_allocator& y)
-        {return x.data_ == y.data_;}
-    friend bool operator!=(const other_allocator& x, const other_allocator& y)
-        {return !(x == y);}
+  TEST_CONSTEXPR_CXX14 other_allocator() {}
+  TEST_CONSTEXPR_CXX14 explicit other_allocator(int i) : data_(i) {}
+
+  template <class U>
+  TEST_CONSTEXPR_CXX14 other_allocator(const other_allocator<U>& a) : data_(a.data_) {}
+
+  TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) { return std::allocator<value_type>().allocate(n); }
+  TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t s) { std::allocator<value_type>().deallocate(p, s); }
+
+  TEST_CONSTEXPR_CXX14 other_allocator select_on_container_copy_construction() const { return other_allocator(-2); }
+
+  TEST_CONSTEXPR_CXX14 friend bool operator==(const other_allocator& x, const other_allocator& y) {
+    return x.data_ == y.data_;
+  }
+
+  TEST_CONSTEXPR_CXX14 friend bool operator!=(const other_allocator& x, const other_allocator& y) { return !(x == y); }
 
-    typedef std::true_type propagate_on_container_copy_assignment;
-    typedef std::true_type propagate_on_container_move_assignment;
-    typedef std::true_type propagate_on_container_swap;
 
 #if TEST_STD_VER < 11
-    std::size_t max_size() const
-        {return UINT_MAX / sizeof(T);}
+  std::size_t max_size() const { return UINT_MAX / sizeof(T); }
 #endif
-
 };
 
 #if TEST_STD_VER >= 11
 
 struct Ctor_Tag {};
 
-template <typename T> class TaggingAllocator;
+template <typename T>
+class TaggingAllocator;
 
 struct Tag_X {
   // All constructors must be passed the Tag type.
 
   // DefaultInsertable into vector<X, TaggingAllocator<X>>,
-  Tag_X(Ctor_Tag) {}
+  constexpr Tag_X(Ctor_Tag) {}
   // CopyInsertable into vector<X, TaggingAllocator<X>>,
-  Tag_X(Ctor_Tag, const Tag_X&) {}
+  constexpr Tag_X(Ctor_Tag, const Tag_X&) {}
   // MoveInsertable into vector<X, TaggingAllocator<X>>, and
-  Tag_X(Ctor_Tag, Tag_X&&) {}
+  constexpr Tag_X(Ctor_Tag, Tag_X&&) {}
 
   // EmplaceConstructible into vector<X, TaggingAllocator<X>> from args.
-  template<typename... Args>
-  Tag_X(Ctor_Tag, Args&&...) { }
+  template <typename... Args>
+  constexpr Tag_X(Ctor_Tag, Args&&...) {}
 
   // not DefaultConstructible, CopyConstructible or MoveConstructible.
   Tag_X() = delete;
   Tag_X(const Tag_X&) = delete;
   Tag_X(Tag_X&&) = delete;
 
   // CopyAssignable.
-  Tag_X& operator=(const Tag_X&) { return *this; }
+  TEST_CONSTEXPR_CXX14 Tag_X& operator=(const Tag_X&) { return *this; };
 
   // MoveAssignable.
-  Tag_X& operator=(Tag_X&&) { return *this; }
+  TEST_CONSTEXPR_CXX14 Tag_X& operator=(Tag_X&&) { return *this; };
 
 private:
-  // Not Destructible.
-  ~Tag_X() { }
-
+  ~Tag_X() = default;
   // Erasable from vector<X, TaggingAllocator<X>>.
   friend class TaggingAllocator<Tag_X>;
 };
 
-
-template<typename T>
+template <typename T>
 class TaggingAllocator {
 public:
-    using value_type = T;
-    TaggingAllocator() = default;
 
-    template<typename U>
-      TaggingAllocator(const TaggingAllocator<U>&) { }
-
-    T* allocate(std::size_t n) { return std::allocator<T>{}.allocate(n); }
-
-    void deallocate(T* p, std::size_t n) { std::allocator<T>{}.deallocate(p, n); }
+  template <typename U>
+  constexpr TaggingAllocator(const TaggingAllocator<U>&){};
 
-    template<typename... Args>
-    void construct(Tag_X* p, Args&&... args)
-    { ::new((void*)p) Tag_X(Ctor_Tag{}, std::forward<Args>(args)...); }
+  template <typename... Args>
+  void construct(Tag_X* p, Args&&... args) {
+    ::new ((void*)p) Tag_X(Ctor_Tag{}, std::forward<Args>(args)...);
+  }
+
+  template <typename U>
+  void destroy(U* p) {
+    p->~U();
+  }
 
-    template<typename U, typename... Args>
-    void construct(U* p, Args&&... args)
-    { ::new((void*)p) U(std::forward<Args>(args)...); }
-
-    template<typename U, typename... Args>
-    void destroy(U* p)
-    { p->~U(); }
-};
-
-template<typename T, typename U>
-bool
-operator==(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
-{ return true; }
-
-template<typename T, typename U>
-bool
-operator!=(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
-{ return false; }
+  TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) { return std::allocator<T>{}.allocate(n); }
+  TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t n) { std::allocator<T>{}.deallocate(p, n); }
+};
 #endif
 
 template <std::size_t MaxAllocs>
 struct limited_alloc_handle {
-  std::size_t outstanding_;
-  void* last_alloc_;
-
-  limited_alloc_handle() : outstanding_(0), last_alloc_(nullptr) {}
+  std::size_t outstanding_ = 0;
+  void* last_alloc_ = nullptr;
 
   template <class T>
-  T *allocate(std::size_t N) {
+  TEST_CONSTEXPR_CXX20 T* allocate(std::size_t N) {
     if (N + outstanding_ > MaxAllocs)
       TEST_THROW(std::bad_alloc());
-    last_alloc_ = ::operator new(N*sizeof(T));
+    last_alloc_ = std::allocator<T>().allocate(N);
     outstanding_ += N;
     return static_cast<T*>(last_alloc_);
   }
 
-  void deallocate(void* ptr, std::size_t N) {
+  template <class T>
+  TEST_CONSTEXPR_CXX20 void deallocate(T* ptr, std::size_t N) {
     if (ptr == last_alloc_) {
       last_alloc_ = nullptr;
       assert(outstanding_ >= N);
       outstanding_ -= N;
     }
-    ::operator delete(ptr);
+    std::allocator<T>().deallocate(ptr, N);
   }
 };
 
+namespace detail {
+template <class T>
+class thread_unsafe_shared_ptr {
+public:
+  thread_unsafe_shared_ptr() = default;
+
+  TEST_CONSTEXPR_CXX14 thread_unsafe_shared_ptr(const thread_unsafe_shared_ptr& other) : block(other.block) {
+    ++block->ref_count;
+  }
+
+  TEST_CONSTEXPR_CXX20 ~thread_unsafe_shared_ptr() {
+    --block->ref_count;
+    if (block->ref_count != 0)
+      return;
+    typedef std::allocator_traits<std::allocator<control_block> > allocator_traits;
+    std::allocator<control_block> alloc;
+    allocator_traits::destroy(alloc, block);
+    allocator_traits::deallocate(alloc, block, 1);
+  }
+
+  TEST_CONSTEXPR const T& operator*() const { return block->content; }
+  TEST_CONSTEXPR const T* operator->() const { return &block->content; }
+  TEST_CONSTEXPR_CXX14 T& operator*() { return block->content; }
+  TEST_CONSTEXPR_CXX14 T* operator->() { return &block->content; }
+  TEST_CONSTEXPR_CXX14 T* get() { return &block->content; }
+  TEST_CONSTEXPR const T* get() const { return &block->content; }
+
+private:
+  struct control_block {
+    template <class... Args>
+    TEST_CONSTEXPR control_block(Args... args) : content(std::forward<Args>(args)...) {}
+    size_t ref_count = 1;
+    T content;
+  };
+
+  control_block* block = nullptr;
+
+  template <class U, class... Args>
+  friend TEST_CONSTEXPR_CXX20 thread_unsafe_shared_ptr<U> make_thread_unsafe_shared(Args...);
+};
+
+template <class T, class... Args>
+TEST_CONSTEXPR_CXX20 thread_unsafe_shared_ptr<T> make_thread_unsafe_shared(Args... args) {
+  typedef typename thread_unsafe_shared_ptr<T>::control_block control_block_type;
+  typedef std::allocator_traits<std::allocator<control_block_type> > allocator_traits;
+
+  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, std::size_t N>
-class limited_allocator
-{
-    template <class U, std::size_t UN> friend class limited_allocator;
-    typedef limited_alloc_handle<N> BuffT;
-    std::shared_ptr<BuffT> handle_;
+class limited_allocator {
+  template <class U, std::size_t UN>
+  friend class limited_allocator;
+  detail::thread_unsafe_shared_ptr<BuffT> handle_;
+
 public:
-    typedef T                 value_type;
-    typedef value_type*       pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type&       reference;
-    typedef const value_type& const_reference;
-    typedef std::size_t       size_type;
-    typedef std::ptrdiff_t    difference_type;
+  typedef T value_type;
+  typedef value_type* pointer;
+  typedef value_type& reference;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
 
-    template <class U> struct rebind { typedef limited_allocator<U, N> other; };
+  template <class U>
+  struct rebind {
+    typedef limited_allocator<U, N> other;
+  };
 
-    limited_allocator() : handle_(new BuffT) {}
+  TEST_CONSTEXPR_CXX20 limited_allocator() : handle_(detail::make_thread_unsafe_shared<BuffT>()) {}
 
-    limited_allocator(limited_allocator const& other) : handle_(other.handle_) {}
+  limited_allocator(limited_allocator const&) = default;
 
-    template <class U>
-    explicit limited_allocator(limited_allocator<U, N> const& other)
-        : handle_(other.handle_) {}
+  TEST_CONSTEXPR explicit limited_allocator(limited_allocator<U, N> const& other) : handle_(other.handle_) {}
 
-    limited_allocator& operator=(const limited_allocator&) = delete;
 
-    pointer allocate(size_type n) { return handle_->template allocate<T>(n); }
-    void deallocate(pointer p, size_type n) { handle_->deallocate(p, n); }
-    size_type max_size() const {return N;}
-
-    BuffT* getHandle() const { return handle_.get(); }
+  TEST_CONSTEXPR_CXX20 pointer allocate(size_type n) { return handle_->template allocate<T>(n); }
+  TEST_CONSTEXPR_CXX20 void deallocate(pointer p, size_type n) { handle_->template deallocate<T>(p, n); }
+  TEST_CONSTEXPR size_type max_size() const { return N; }
+  TEST_CONSTEXPR BuffT* getHandle() const { return handle_.get(); }
 };
 
 template <class T, class U, std::size_t N>
-inline bool operator==(limited_allocator<T, N> const& LHS,
-                       limited_allocator<U, N> const& RHS) {
+TEST_CONSTEXPR inline bool operator==(limited_allocator<T, N> const& LHS, limited_allocator<U, N> const& RHS) {
   return LHS.getHandle() == RHS.getHandle();
 }
 
 template <class T, class U, std::size_t N>
-inline bool operator!=(limited_allocator<T, N> const& LHS,
-                       limited_allocator<U, N> const& RHS) {
+TEST_CONSTEXPR inline bool operator!=(limited_allocator<T, N> const& LHS, limited_allocator<U, N> const& RHS) {
   return !(LHS == RHS);
 }
 
-
 #endif // TEST_ALLOCATOR_H