[libc++][test] Port memory_resource tests to MSVCSTL

[CaseyCarter]

Summary

• Reject Initialization of polymorphic_allocator from nullptr per [mem.poly.allocator.ctor]/2.
• Use new char[n] instead of malloc(n) to avoid warnings about dereferencing potentially null pointers.
• MSVCSTL doesn't implement LWG-3120 (cursed ABI); XFAIL monotonic_buffer_resource::reset test.
• Don't expect to portably be able to allocate 0 bytes from a potentially-exhausted block in monotonic_buffer_resource. Zero-byte allocations may still consume block space to provide that guarantee that a return value cannot repeat absent deallocation/reset. LWG-3637 "pmr::memory_resource::do_allocate needs clarification" is pertinent here.
• MSVCSTL's pool resources use a vector internally, so they perform an additional allocation when iterator debugging. This requires adjustment to the expected number of allocations for some tests, and completely disabling the case that sets the default resource to null_memory_resource.

[philnik]

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

41–42

Does this change alignment guarantees?

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/resource.pass.cpp

36

I think this should be removed and we should add a _LIBCPP_ASSERT(__r != nullptr, "memory_resource pointer has to be non-null"); in the constructor instead.

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/select_on_container_copy_construction.pass.cpp

30

Missing <cstdlib> include.

59–61

Why the special-casing for libc++?

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_from_underaligned_buffer.pass.cpp

49

Couldn't you just test this downstream and just have #ifndef _MSVC_STL_VERSION around the assert?

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_with_initial_size.pass.cpp

38

What's the problem here?

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/ctor_does_not_allocate.pass.cpp

23–26

AFAICT this is non-conforming and should therefore not be tested here. Instead, this test should be XFAILed for the problematic case, since it's all that is tested. Same for the cases below.

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/sync_with_default_resource.pass.cpp

23

What is the problem here? Same question below.

[CaseyCarter]

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

41–42

It does not. malloc (C 7.24.3) returns a pointer aligned for "any type of object with a fundamental alignment requirement and size less than or equal to the size requested", whereas new char[n] gets storage from operator new[] ([basic.stc.dynamic.allocation]/3.2) which is "aligned for any object that does not have new-extended alignment and is no larger than the request size" (at least as strict a requirement as "fundamental alignment") which it might offset by a multiple of the fundamental alignment requirement ([expr.new]/16).

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/select_on_container_copy_construction.pass.cpp

59–61

Just to preserve the nullptr behavior. Since you've suggested above that the constructor should refuse nullptr - which I agree is a good idea - I'll remove the special-case here.

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_from_underaligned_buffer.pass.cpp

49

I want the test to break loudly when we implement LWG-3120, which honestly I could do as well by XFAILing it in our out-of-band control structure. On further thought I believe that's preferable: the cases that do pass here pass for the wrong reasons, so this test would be incredibly fragile for us. I'll revert this part of the change (leaving the comment fix and the change from assert to ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS).

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_with_initial_size.pass.cpp

38

LWG-3637 will possibly make it a requirement that allocate may not return the same pointer twice without intervening deallocation. That requirement can't be satisfied by an implementation that allocates 0 bytes from an exhausted block - as test(1) expects - since repeated calls would presumably return the same address. Making this case libc++-only allows implementations like MSVCSTL to pass as well.

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/ctor_does_not_allocate.pass.cpp

23–26

I believe it is conforming; the Standard gives a lot of leeway with "It is unspecified if, or under what conditions, this constructor calls upstream->allocate()" ([mem.res.pool.ctor]/3).

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/sync_with_default_resource.pass.cpp

23

Same as the previous test: our pool resources allocate on construction when iterator debugging is active, so line 26 and 27 fail horribly. I believe this part of the test is non-portable. Maybe it would be better to make it libc++-specific? (Same response below.)

[CaseyCarter]

Review comments.

[philnik]

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

41–42

Thanks for the info!

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/ctor_does_not_allocate.pass.cpp

23–26

I guess you are right. IMO this should be a libc++-specific test then, since it tests implementation details which are unspecified in the standard.

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/sync_with_default_resource.pass.cpp

23

Yes, I think this should be libc++ specific then.

[ldionne]

Gentle ping, do we still want to do this?

[CaseyCarter]

Abandoning this for now since I haven't had time to complete it. I'll bring this back on GitHub when I find the time.

libcxx/include/__memory_resource/polymorphic_allocator.h

 
 public:
   using value_type = _ValueType;
 
   // [mem.poly.allocator.ctor]
 
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator() noexcept : __res_(std::pmr::get_default_resource()) {}
 
-  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(memory_resource* __r) noexcept : __res_(__r) {}
+  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(memory_resource* __r) noexcept : __res_(__r) {
+    _LIBCPP_ASSERT(__r != nullptr, "memory_resource pointer must be non-null");
+  }
 
   polymorphic_allocator(const polymorphic_allocator&) = default;
 
   template <class _Tp>
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(const polymorphic_allocator<_Tp>& __other) noexcept
       : __res_(__other.resource()) {}
 
   polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

 // template <class P1, class P2, class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> const&)
 
 #include <memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
 #include "test_std_memory_resource.h"
 #include "uses_alloc_types.h"
 #include "controlled_allocators.h"
 #include "test_allocator.h"
 
 template <class UA1, class UA2, class TT, class UU>
 bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, std::pair<TT, UU> const& p) {
   using P = std::pair<UA1, UA2>;
   TestResource R;
   std::pmr::memory_resource* M = &R;
   std::pmr::polymorphic_allocator<P> A(M);
-  P* ptr  = (P*)std::malloc(sizeof(P));
-  P* ptr2 = (P*)std::malloc(sizeof(P));
+  P* ptr  = (P*)new char[sizeof(P)];
+  P* ptr2 = (P*)new char[sizeof(P)];
 
   // UNDER TEST //
   A.construct(ptr, p);
 
   A.construct(ptr2, std::piecewise_construct, std::forward_as_tuple(p.first), std::forward_as_tuple(p.second));
   // ------- //
 
   bool tres =
       checkConstruct<decltype((p.first))>(ptr->first, TExpect, M) && checkConstructionEquiv(ptr->first, ptr2->first);
 
   bool ures = checkConstruct<decltype((p.second))>(ptr->second, UExpect, M) &&
               checkConstructionEquiv(ptr->second, ptr2->second);
 
   A.destroy(ptr);
-  std::free(ptr);
+  delete[] ptr;
   A.destroy(ptr2);
-  std::free(ptr2);
+  delete[] ptr2;
   return tres && ures;
 }
 
 template <class Alloc, class TT, class UU>
 void test_pmr_uses_allocator(std::pair<TT, UU> const& p) {
   {
     using T = NotUsesAllocator<Alloc, 1>;
     using U = NotUsesAllocator<Alloc, 1>;

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_values.pass.cpp

 #include "test_allocator.h"
 
 template <class UA1, class UA2, class TT, class UU>
 bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, TT&& t, UU&& u) {
   using P = std::pair<UA1, UA2>;
   TestResource R;
   std::pmr::memory_resource* M = &R;
   std::pmr::polymorphic_allocator<P> A(M);
-  P* ptr  = (P*)std::malloc(sizeof(P));
-  P* ptr2 = (P*)std::malloc(sizeof(P));
+  P* ptr  = (P*)new char[sizeof(P)];
+  P* ptr2 = (P*)new char[sizeof(P)];
 
   // UNDER TEST //
   A.construct(ptr, std::forward<TT>(t), std::forward<UU>(u));
   A.construct(ptr2,
               std::piecewise_construct,
               std::forward_as_tuple(std::forward<TT>(t)),
               std::forward_as_tuple(std::forward<UU>(u)));
   // ------- //
 
   bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) && checkConstructionEquiv(ptr->first, ptr2->first);
 
   bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) && checkConstructionEquiv(ptr->second, ptr2->second);
 
   A.destroy(ptr);
   A.destroy(ptr2);
-  std::free(ptr);
-  std::free(ptr2);
+  delete[] ptr;
+  delete[] ptr2;
   return tres && ures;
 }
 
 template <class Alloc, class TT, class UU>
 void test_pmr_uses_allocator(TT&& t, UU&& u) {
   {
     using T = NotUsesAllocator<Alloc, 1>;
     using U = NotUsesAllocator<Alloc, 1>;

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/resource.pass.cpp

typedef std::pmr::polymorphic_allocator<void> A;
     A const a;
     ASSERT_SAME_TYPE(decltype(a.resource()), std::pmr::memory_resource*);
   }
   {
     std::pmr::memory_resource* mptr = (std::pmr::memory_resource*)42;
     A const a(mptr);
     assert(a.resource() == mptr);
   }
   {
-    A const a(nullptr);
-    assert(a.resource() == nullptr);
-    assert(a.resource() == nullptr);
-  }
-  {
     A const a;
     assert(a.resource() == std::pmr::get_default_resource());
   }
   {
     std::pmr::memory_resource* mptr = (std::pmr::memory_resource*)42;
     std::pmr::set_default_resource(mptr);
     A const a;
     assert(a.resource() == mptr);
     assert(a.resource() == std::pmr::get_default_resource());
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/select_on_container_copy_construction.pass.cpp

 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator
 // polymorphic_allocator<T>::select_on_container_copy_construction() const
 
 #include <memory_resource>
 #include <cassert>
+#include <cstdlib>
 
 #include "test_macros.h"
 
+namespace {
+  struct resource : std::pmr::memory_resource {
+    void* do_allocate(std::size_t, std::size_t) override {
+      std::abort();
+    }
+
+    void do_deallocate(void*, std::size_t, std::size_t) override {
+      std::abort();
+    }
+
+    bool do_is_equal(const std::pmr::memory_resource& that) const noexcept override {
+      return dynamic_cast<const resource*>(&that) != nullptr;
+    }
+  } a_resource;
+}
+
 int main(int, char**) {
   typedef std::pmr::polymorphic_allocator<void> A;
   {
     A const a;
     ASSERT_SAME_TYPE(decltype(a.select_on_container_copy_construction()), A);
   }
   {
     std::pmr::memory_resource* mptr = (std::pmr::memory_resource*)42;
     A const a(mptr);
     assert(a.resource() == mptr);
     A const other = a.select_on_container_copy_construction();
     assert(other.resource() == std::pmr::get_default_resource());
     assert(a.resource() == mptr);
   }
   {
     std::pmr::memory_resource* mptr = (std::pmr::memory_resource*)42;
     std::pmr::set_default_resource(mptr);
-    A const a(nullptr);
-    assert(a.resource() == nullptr);
+    std::pmr::memory_resource* mptr2 = &a_resource;
+    A const a(mptr2);
+    assert(a.resource() == mptr2);
     A const other = a.select_on_container_copy_construction();
     assert(other.resource() == std::pmr::get_default_resource());
     assert(other.resource() == mptr);
-    assert(a.resource() == nullptr);
+    assert(a.resource() == mptr2);
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_from_underaligned_buffer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}}
 
+// MSVC can't implement LWG-3120 until the next ABI break (microsoft/STL#1468)
+// XFAIL: stdlib=msvc
+
 // <memory_resource>
 
 // class monotonic_buffer_resource
 
 #include <memory_resource>
 #include <cassert>
 
 #include "count_new.h"
globalMemCounter.reset();
     assert(ret == buffer + 2);
     mono1.release();
 
     ret = r1.allocate(1, 4);
     assert(ret == buffer + 4);
     mono1.release();
 
     // Test a size that is just big enough to fit in the buffer,
-    // but can't fit if it's aligned.
+    // but will not fit with alignment greater than 1.
     ret = r1.allocate(16, 1);
     assert(ret == buffer + 1);
     mono1.release();
 
-    assert(globalMemCounter.checkNewCalledEq(0));
+    ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledEq(0));
     ret = r1.allocate(16, 2);
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledEq(1));
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkLastNewSizeGe(16));
     mono1.release();
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkDeleteCalledEq(1));
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_with_initial_size.pass.cpp

void test(size_t initial_buffer_size) {
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledEq(1));
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkLastNewSizeGe(initial_buffer_size));
 
   (void)mono1.allocate(initial_buffer_size - 1, 1);
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledEq(1));
 }
 
 int main(int, char**) {
+#ifdef _LIBCPP_VERSION
   test(1);
+#endif
   test(8);
   test(10);
   test(100);
   test(256);
   test(1000);
   test(1024);
   test(1000000);
   assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/ctor_does_not_allocate.pass.cpp

 // class synchronized_pool_resource
 // class unsynchronized_pool_resource
 
 #include <memory_resource>
 #include <cassert>
 
 #include "count_new.h"
 
+#if defined(_MSVC_STL_VERSION) && _ITERATOR_DEBUG_LEVEL == 2
+// MSVCSTL's pool resources use a vector internally, which allocates a tracking
+// object when iterator debugging
+constexpr int alloc_delta = 1;
+#else
+constexpr int alloc_delta = 0;
+#endif
+
 template <class PoolResource>
 void test() {
   // Constructing a pool resource should not cause allocations
   // by itself; the resource should wait to allocate until an
   // allocation is requested.
 
   globalMemCounter.reset();
   std::pmr::set_default_resource(std::pmr::new_delete_resource());
 
   PoolResource r1;
-  assert(globalMemCounter.checkNewCalledEq(0));
+  assert(globalMemCounter.checkNewCalledEq(alloc_delta));
 
   PoolResource r2(std::pmr::pool_options{1024, 2048});
-  assert(globalMemCounter.checkNewCalledEq(0));
+  assert(globalMemCounter.checkNewCalledEq(2 * alloc_delta));
 
   PoolResource r3(std::pmr::pool_options{1024, 2048}, std::pmr::new_delete_resource());
-  assert(globalMemCounter.checkNewCalledEq(0));
+  assert(globalMemCounter.checkNewCalledEq(3 * alloc_delta));
 }
 
 int main(int, char**) {
   test<std::pmr::unsynchronized_pool_resource>();
   test<std::pmr::synchronized_pool_resource>();
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/sync_with_default_resource.pass.cpp

 // class synchronized_pool_resource
 
 #include <memory_resource>
 #include <cassert>
 
 int main(int, char**) {
   std::pmr::memory_resource* expected = std::pmr::null_memory_resource();
   std::pmr::set_default_resource(expected);
+#if !defined(_MSVC_STL_VERSION) || !defined(_DEBUG)
   {
     std::pmr::pool_options opts{0, 0};
     std::pmr::synchronized_pool_resource r1;
     std::pmr::synchronized_pool_resource r2(opts);
     assert(r1.upstream_resource() == expected);
     assert(r2.upstream_resource() == expected);
   }
+#endif // !defined(_MSVC_STL_VERSION) || !defined(_DEBUG)
 
   expected = std::pmr::new_delete_resource();
   std::pmr::set_default_resource(expected);
   {
     std::pmr::pool_options opts{1024, 2048};
     std::pmr::synchronized_pool_resource r1;
     std::pmr::synchronized_pool_resource r2(opts);
     assert(r1.upstream_resource() == expected);
     assert(r2.upstream_resource() == expected);
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/unsync_with_default_resource.pass.cpp

 // class unsynchronized_pool_resource
 
 #include <memory_resource>
 #include <cassert>
 
 int main(int, char**) {
   std::pmr::memory_resource* expected = std::pmr::null_memory_resource();
   std::pmr::set_default_resource(expected);
+#if !defined(_MSVC_STL_VERSION) || !defined(_DEBUG)
   {
     std::pmr::pool_options opts{0, 0};
     std::pmr::unsynchronized_pool_resource r1;
     std::pmr::unsynchronized_pool_resource r2(opts);
     assert(r1.upstream_resource() == expected);
     assert(r2.upstream_resource() == expected);
   }
+#endif // !defined(_MSVC_STL_VERSION) || !defined(_DEBUG)
 
   expected = std::pmr::new_delete_resource();
   std::pmr::set_default_resource(expected);
   {
     std::pmr::pool_options opts{1024, 2048};
     std::pmr::unsynchronized_pool_resource r1;
     std::pmr::unsynchronized_pool_resource r2(opts);
     assert(r1.upstream_resource() == expected);
     assert(r2.upstream_resource() == expected);
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/sync_allocate.pass.cpp

 // class synchronized_pool_resource
 
 #include <memory_resource>
 #include <cassert>
 
 #include "count_new.h"
 #include "test_macros.h"
 
+#if defined(_MSVC_STL_VERSION) && _ITERATOR_DEBUG_LEVEL == 2
+// MSVCSTL's pool resources use a vector internally, which allocates a tracking
+// object when iterator debugging
+constexpr int alloc_delta = 1;
+#else
+constexpr int alloc_delta = 0;
+#endif
+
 int main(int, char**) {
   globalMemCounter.reset();
   {
     auto sync1                    = std::pmr::synchronized_pool_resource(std::pmr::new_delete_resource());
     std::pmr::memory_resource& r1 = sync1;
 
     void* ret = r1.allocate(50);
     assert(ret);
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(0));
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkDeleteCalledEq(0));
 
     r1.deallocate(ret, 50);
     sync1.release();
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkDeleteCalledGreaterThan(0));
-    assert(globalMemCounter.checkOutstandingNewEq(0));
+    assert(globalMemCounter.checkOutstandingNewEq(alloc_delta));
 
     globalMemCounter.reset();
 
     ret = r1.allocate(500);
     assert(ret);
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(0));
     assert(globalMemCounter.checkDeleteCalledEq(0));
 
     // Check that the destructor calls release()
   }
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkDeleteCalledGreaterThan(0));
-  assert(globalMemCounter.checkOutstandingNewEq(0));
+  assert(globalMemCounter.checkOutstandingNewEq(-alloc_delta));
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/sync_allocate_overaligned_request.pass.cpp

 
 bool is_aligned_to(void* p, size_t alignment) {
   void* p2     = p;
   size_t space = 1;
   void* result = std::align(alignment, 1, p2, space);
   return (result == p);
 }
 
+#if defined(_MSVC_STL_VERSION) && _ITERATOR_DEBUG_LEVEL == 2
+// MSVCSTL's pool resources use a vector internally, which allocates a tracking
+// object when iterator debugging
+constexpr int alloc_delta = 1;
+#else
+constexpr int alloc_delta = 0;
+#endif
+
 int main(int, char**) {
   globalMemCounter.reset();
   std::pmr::pool_options opts{1, 1024};
   std::pmr::synchronized_pool_resource sync1(opts, std::pmr::new_delete_resource());
   std::pmr::memory_resource& r1 = sync1;
 
   constexpr size_t big_alignment = 8 * alignof(std::max_align_t);
   static_assert(big_alignment > 4);
 
-  assert(globalMemCounter.checkNewCalledEq(0));
+  assert(globalMemCounter.checkNewCalledEq(alloc_delta));
 
   void* ret = r1.allocate(2048, big_alignment);
   assert(ret != nullptr);
   assert(is_aligned_to(ret, big_alignment));
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(0));
 
   ret = r1.allocate(16, 4);
   assert(ret != nullptr);
   assert(is_aligned_to(ret, 4));
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(1));
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/sync_deallocate_matches_allocate.pass.cpp

class test_resource : public std::pmr::memory_resource {
   }
   bool do_is_equal(const std::pmr::memory_resource&) const noexcept override { return false; }
 
 public:
   std::vector<allocation_record> successful_allocations;
   std::vector<allocation_record> deallocations;
 };
 
+#if defined(_MSVC_STL_VERSION) && _ITERATOR_DEBUG_LEVEL == 2
+// MSVCSTL's pool resources use a vector internally, which allocates a tracking
+// object when iterator debugging
+constexpr int alloc_delta = 1;
+#else
+constexpr int alloc_delta = 0;
+#endif
+
 template <class F>
 void test_allocation_pattern(F do_pattern) {
   test_resource tr;
+  {
     std::pmr::pool_options opts{0, 256};
     std::pmr::synchronized_pool_resource spr(opts, &tr);
 
     try {
       do_pattern(spr);
     } catch (const std::bad_alloc&) {
     }
     spr.release();
 
-  assert(tr.successful_allocations.size() == tr.deallocations.size());
+    assert(tr.successful_allocations.size() == tr.deallocations.size() + alloc_delta);
+  }
+
   assert(std::is_permutation(
       tr.successful_allocations.begin(),
       tr.successful_allocations.end(),
       tr.deallocations.begin(),
       tr.deallocations.end()));
 }
 
 template <size_t Bytes, size_t Align>

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_allocate.pass.cpp

 // class unsynchronized_pool_resource
 
 #include <memory_resource>
 #include <cassert>
 
 #include "count_new.h"
 #include "test_macros.h"
 
+#if defined(_MSVC_STL_VERSION) && _ITERATOR_DEBUG_LEVEL == 2
+// MSVCSTL's pool resources use a vector internally, which allocates a tracking
+// object when iterator debugging
+constexpr int alloc_delta = 1;
+#else
+constexpr int alloc_delta = 0;
+#endif
+
 int main(int, char**) {
   globalMemCounter.reset();
   {
     auto unsync1                  = std::pmr::unsynchronized_pool_resource(std::pmr::new_delete_resource());
     std::pmr::memory_resource& r1 = unsync1;
 
     void* ret = r1.allocate(50);
     assert(ret);
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(0));
     assert(globalMemCounter.checkDeleteCalledEq(0));
 
     r1.deallocate(ret, 50);
     unsync1.release();
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkDeleteCalledGreaterThan(0));
-    assert(globalMemCounter.checkOutstandingNewEq(0));
+    assert(globalMemCounter.checkOutstandingNewEq(alloc_delta));
 
     globalMemCounter.reset();
 
     ret = r1.allocate(500);
     assert(ret);
     ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(0));
     assert(globalMemCounter.checkDeleteCalledEq(0));
 
     // Check that the destructor calls release()
   }
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkDeleteCalledGreaterThan(0));
-  assert(globalMemCounter.checkOutstandingNewEq(0));
+  assert(globalMemCounter.checkOutstandingNewEq(-alloc_delta));
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_allocate_overaligned_request.pass.cpp

 
 bool is_aligned_to(void* p, size_t alignment) {
   void* p2     = p;
   size_t space = 1;
   void* result = std::align(alignment, 1, p2, space);
   return (result == p);
 }
 
+#if defined(_MSVC_STL_VERSION) && _ITERATOR_DEBUG_LEVEL == 2
+// MSVCSTL's pool resources use a vector internally, which allocates a tracking
+// object when iterator debugging
+constexpr int alloc_delta = 1;
+#else
+constexpr int alloc_delta = 0;
+#endif
+
 int main(int, char**) {
   globalMemCounter.reset();
   std::pmr::pool_options opts{1, 1024};
   auto unsync1                  = std::pmr::unsynchronized_pool_resource(opts, std::pmr::new_delete_resource());
   std::pmr::memory_resource& r1 = unsync1;
 
   constexpr size_t big_alignment = 8 * alignof(std::max_align_t);
   static_assert(big_alignment > 4);
 
-  assert(globalMemCounter.checkNewCalledEq(0));
+  assert(globalMemCounter.checkNewCalledEq(alloc_delta));
 
   void* ret = r1.allocate(2048, big_alignment);
   assert(ret != nullptr);
   assert(is_aligned_to(ret, big_alignment));
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(0));
 
   ret = r1.allocate(16, 4);
   assert(ret != nullptr);
   assert(is_aligned_to(ret, 4));
   ASSERT_WITH_LIBRARY_INTERNAL_ALLOCATIONS(globalMemCounter.checkNewCalledGreaterThan(1));
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_deallocate_matches_allocate.pass.cpp

class test_resource : public std::pmr::memory_resource {
   }
   bool do_is_equal(const std::pmr::memory_resource&) const noexcept override { return false; }
 
 public:
   std::vector<allocation_record> successful_allocations;
   std::vector<allocation_record> deallocations;
 };
 
+#if defined(_MSVC_STL_VERSION) && _ITERATOR_DEBUG_LEVEL == 2
+// MSVCSTL's pool resources use a vector internally, which allocates a tracking
+// object when iterator debugging
+constexpr int alloc_delta = 1;
+#else
+constexpr int alloc_delta = 0;
+#endif
+
 template <class F>
 void test_allocation_pattern(F do_pattern) {
   test_resource tr;
+  {
     std::pmr::pool_options opts{0, 256};
     std::pmr::unsynchronized_pool_resource uspr(opts, &tr);
 
     try {
       do_pattern(uspr);
     } catch (const std::bad_alloc&) {
     }
     uspr.release();
 
-  assert(tr.successful_allocations.size() == tr.deallocations.size());
+    assert(tr.successful_allocations.size() == tr.deallocations.size() + alloc_delta);
+  }
+
   assert(std::is_permutation(
       tr.successful_allocations.begin(),
       tr.successful_allocations.end(),
       tr.deallocations.begin(),
       tr.deallocations.end()));
 }
 
 template <size_t Bytes, size_t Align>