[libcxx] Consolidate new/delete replacement in tests and disable it when using sanitizers.

Summary:
MSAN and ASAN also replace new/delete which leads to a link error in these tests. Currently they are unsupported but I think it would be useful if these tests could run with sanitizers.

This patch creates a support header that consolidates the new/delete replacement functionality and checking.
When we are using sanitizers new and delete are no longer replaced and the checks always return true.

Reviewers: mclow.lists, danalbert, jroelofs, EricWF

Reviewed By: EricWF

Subscribers: cfe-commits

Differential Revision: http://reviews.llvm.org/D6562

llvm-svn: 224741

9 files changed, 95 insertions, 235 deletions

diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
index b8995bffe0f..58192c928d5 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
@@ -14,26 +14,12 @@
 // template <MoveConstructible  R, MoveConstructible ... ArgTypes>
 //   void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
 
-// UNSUPPORTED: asan, msan
 
 #include <functional>
-#include <new>
 #include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -73,65 +59,65 @@ int h(int) {return 1;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = A(2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f1.target<A>()->id() == 1);
     assert(f2.target<A>()->id() == 2);
     swap(f1, f2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f1.target<A>()->id() == 2);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = g;
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     swap(f1, f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = A(1);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     swap(f1, f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = h;
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(*f1.target<int(*)(int)>() == g);
     assert(*f2.target<int(*)(int)>() == h);
     swap(f1, f2);
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(*f1.target<int(*)(int)>() == h);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
index 3a43be73f7a..f506af0e001 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
@@ -13,26 +13,10 @@
 
 // function(nullptr_t);
 
-// UNSUPPORTED: asan, msan
-
 #include <functional>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -67,34 +51,34 @@ int g(int) {return 0;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = (int (*)(int))0;
     assert(!f);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     }
     {
     std::function<int(const A*, int)> f = &A::foo;
     assert(f);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int (A::*)(int) const>() != 0);
     }
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
index ba65cd3330b..7784943cb13 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
@@ -16,26 +16,10 @@
 //         && Convertible<Callable<F, ArgTypes...>::result_type
 //   operator=(F f);
 
-// UNSUPPORTED: asan, msan
-
 #include <functional>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -70,30 +54,30 @@ int g(int) {return 0;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f;
     f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f;
     f = g;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f;
     f = (int (*)(int))0;
     assert(!f);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     }
@@ -101,7 +85,7 @@ int main()
     std::function<int(const A*, int)> f;
     f = &A::foo;
     assert(f);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int (A::*)(int) const>() != 0);
     }
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
index 38e65fc845f..15bf3398f5f 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
@@ -13,28 +13,12 @@
 
 // template<class A> function(allocator_arg_t, const A&, const function&);
 
-// UNSUPPORTED: asan, msan
 
 #include <functional>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
 #include "test_allocator.h"
-
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -67,48 +51,48 @@ int g(int) {return 0;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2(std::allocator_arg, test_allocator<A>(), f);
     assert(A::count == 2);
-    assert(new_called == 2);
+    assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     std::function<int(int)> f2(std::allocator_arg, test_allocator<int(*)(int)>(), f);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     non_default_test_allocator<std::function<int(int)>> al(1);
     std::function<int(int)> f2(std::allocator_arg, al, g);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     std::function<int(int)> f2(std::allocator_arg, test_allocator<int>(), f);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int(*)(int)>() == 0);
     assert(f2.target<A>() == 0);
     }
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
index 2180b8936d7..15b7c8b5aa4 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
@@ -13,26 +13,11 @@
 
 // template<class A> function(allocator_arg_t, const A&, function&&);
 
-// UNSUPPORTED: asan, msan
-
 #include <functional>
 #include <cassert>
 
 #include "test_allocator.h"
-
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -64,16 +49,16 @@ int A::count = 0;
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2(std::allocator_arg, test_allocator<A>(), std::move(f));
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp
index 2fbd7cfa9fb..f603da9dd13 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp
@@ -13,26 +13,11 @@
 
 // function(const function& f);
 
-// UNSUPPORTED: asan, msan
-
 #include <functional>
-#include <new>
 #include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -65,65 +50,65 @@ int g(int) {return 0;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2 = f;
     assert(A::count == 2);
-    assert(new_called == 2);
+    assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     std::function<int(int)> f2 = f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     std::function<int(int)> f2 = f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int(*)(int)>() == 0);
     assert(f2.target<A>() == 0);
     }
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     assert(!f);
     std::function<long(int)> g = f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(g.target<long(*)(int)>() == 0);
     assert(g.target<A>() == 0);
     assert(!g);
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2 = std::move(f);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
index cfa79e24401..c91eaa2d567 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
@@ -13,26 +13,10 @@
 
 // function& operator=(const function& f);
 
-// UNSUPPORTED: asan, msan
-
 #include <functional>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -65,57 +49,57 @@ int g(int) {return 0;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2;
     f2 = f;
     assert(A::count == 2);
-    assert(new_called == 2);
+    assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     std::function<int(int)> f2;
     f2 = f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     std::function<int(int)> f2;
     f2 = f;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int(*)(int)>() == 0);
     assert(f2.target<A>() == 0);
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2;
     f2 = std::move(f);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
index b8c597b63ce..9b2482fb9d5 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
@@ -13,26 +13,10 @@
 
 // function& operator=(nullptr_t);
 
-// UNSUPPORTED: asan, msan
-
 #include <functional>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -65,24 +49,24 @@ int g(int) {return 0;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     f = nullptr;
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<A>() == 0);
     }
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     f = nullptr;
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     }
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
index 3c012d1db4f..f94e689b2a6 100644
--- a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
@@ -13,26 +13,10 @@
 
 // void swap(function& other);
 
-// UNSUPPORTED: asan, msan
-
 #include <functional>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 class A
 {
@@ -72,65 +56,65 @@ int h(int) {return 1;}
 
 int main()
 {
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = A(2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f1.target<A>()->id() == 1);
     assert(f2.target<A>()->id() == 2);
     f1.swap(f2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f1.target<A>()->id() == 2);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = g;
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     f1.swap(f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = A(1);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     f1.swap(f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = h;
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(*f1.target<int(*)(int)>() == g);
     assert(*f2.target<int(*)(int)>() == h);
     f1.swap(f2);
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(*f1.target<int(*)(int)>() == h);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }