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

[EricWF]

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.

[EricWF]

test/localization/locale.stdcvt/codecvt_utf16.pass.cpp

38–42

I'm not sure why it checks that p is not null. I added an assertion and it never fired. Should count_new.hpp also assert deleted pointers are non-null? Obviously passing a nullptr to delete is legal but I'm not sure why we would be doing that.

[jroelofs]

test/support/count_new.hpp

8

For avoidance of macros, how about something like this:

class MemCounter {
private:
  int new_called;
public:
  bool checkNewCallsEq(int N) {
#if !__has_feature(address_sanitizer) && !__has_feature(memory_sanitizer)
    return new_called == N;
#else
    return true;
#endif
  }
};

MemCounter globalMemCounter; 

#if !__has_feature(address_sanitizer) && !__has_feature(memory_sanitizer)
void* operator new(std::size_t s) throw(std::bad_alloc) {
    ...
}
#endif

And then in the individual tests:

assert(globalMemCounter.checkNewCallsEq(0));

And then if we want to be even more fancy later on, the MemCounter objects could be set up to count only within a scope by allowing them to register with each other to listen for these events. That seems like it'd be beneficial for at least utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp, and possibly others.

54

Do MSan and ASan have hooks that we could use to implement these checks when they're enabled?

[EricWF]

test/support/count_new.hpp

8

I like it! Much cleaner than what we have now. Thanks!

[EricWF]

Mostly address @jroelofs comments.

[jroelofs]

test/support/count_new.hpp

49

Hmm... I just realized that these have really weird names. new_called doesn't count the number of times new was called, rather it counts the number of objects allocated by new that haven't been deleted yet (i.e. the tests don't care if there are extra allocations and deallocations between checks).

[EricWF]

Address @jroelofs point that the variables are poorly named. I introduced outstanding_new to replace count_new and count_new now acts as a monotonic counter.

[jroelofs]

test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

27

I think we're losing test coverage now that this assert is gone :(

[EricWF]

test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

27

We shouldn't be. I added assertions on line 38 and line 47 that check the same thing.

[jroelofs]

Looks good to me.

test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

27

Oh, I missed that.

[EricWF]

Updating patch against TOT.

[EricWF]

Accepting.

test/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp

 
 // ~ctype();
 
-// UNSUPPORTED: asan, msan
-
 #include <locale>
 #include <cassert>
-#include <new>
-
-unsigned delete_called = 0;
 
-void* operator new[](size_t sz) throw(std::bad_alloc)
-{
-    return operator new(sz);
-}
-
-void operator delete[](void* p) throw()
-{
-    operator delete(p);
-    ++delete_called;
-}
+#include "count_new.hpp"
 
 int main()
 {
     {
-        delete_called = 0;
+        delete_array_called = 0;
         std::locale l(std::locale::classic(), new std::ctype<char>);
-        assert(delete_called == 0);
+        COUNT_NEW_ASSERT(delete_array_called == 0);
     }
-    assert(delete_called == 0);
+    COUNT_NEW_ASSERT(delete_array_called == 0);
     {
         std::ctype<char>::mask table[256];
-        delete_called = 0;
+        delete_array_called = 0;
         std::locale l(std::locale::classic(), new std::ctype<char>(table));
-        assert(delete_called == 0);
+        COUNT_NEW_ASSERT(delete_array_called == 0);
     }
-    assert(delete_called == 0);
+    COUNT_NEW_ASSERT(delete_array_called == 0);
     {
-        delete_called = 0;
+        delete_array_called = 0;
         std::locale l(std::locale::classic(),
             new std::ctype<char>(new std::ctype<char>::mask[256], true));
-        assert(delete_called == 0);
+        COUNT_NEW_ASSERT(delete_array_called == 0);
     }
-    assert(delete_called == 1);
+    COUNT_NEW_ASSERT(delete_array_called == 1);
 }

test/localization/locale.stdcvt/codecvt_utf16.pass.cpp

 //     // unspecified
 // };
 
-// UNSUPPORTED: asan, msan
-
 // Not a portable test
 
 #include <codecvt>
 #include <cstdlib>
 #include <cassert>
 
-int outstanding_news = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++outstanding_news;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    if (p)
-    {
-        --outstanding_news;
-        std::free(p);
-    }
-}
+#include "count_new.hpp"
 
 int main()
 {
-    assert(outstanding_news == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
         typedef std::codecvt_utf16<wchar_t> C;
         C c;
-        assert(outstanding_news == 0);
+        COUNT_NEW_ASSERT(new_called == 0);
     }
     {
         typedef std::codecvt_utf16<wchar_t> C;
         std::locale loc(std::locale::classic(), new C);
-        assert(outstanding_news != 0);
+        COUNT_NEW_ASSERT(new_called != 0);
     }
-    assert(outstanding_news == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
 }

test/localization/locale.stdcvt/codecvt_utf8.pass.cpp

 //     // unspecified
 // };
 
-// UNSUPPORTED: asan, msan
-
 // Not a portable test
 
 #include <codecvt>
 #include <cstdlib>
 #include <cassert>
 
-int outstanding_news = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++outstanding_news;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    if (p)
-    {
-        --outstanding_news;
-        std::free(p);
-    }
-}
+#include "count_new.hpp"
 
 int main()
 {
-    assert(outstanding_news == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
         typedef std::codecvt_utf8<wchar_t> C;
         C c;
-        assert(outstanding_news == 0);
+        COUNT_NEW_ASSERT(new_called == 0);
     }
     {
         typedef std::codecvt_utf8<wchar_t> C;
         std::locale loc(std::locale::classic(), new C);
-        assert(outstanding_news != 0);
+        COUNT_NEW_ASSERT(new_called != 0);
     }
-    assert(outstanding_news == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
 }

test/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp

 // wbuffer_convert(streambuf *bytebuf = 0, Codecvt *pcvt = new Codecvt,
 //                 state_type state = state_type());
 
-// UNSUPPORTED: asan, msan
-
 #include <locale>
 #include <codecvt>
 #include <sstream>
 #include <cassert>
-#include <new>
-
-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"
 
 int main()
 {

     {
         B b;
         assert(b.rdbuf() == nullptr);
-        assert(new_called != 0);
+        COUNT_NEW_ASSERT(new_called != 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
         std::stringstream s;
         B b(s.rdbuf());
         assert(b.rdbuf() == s.rdbuf());
-        assert(new_called != 0);
+        COUNT_NEW_ASSERT(new_called != 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
         std::stringstream s;
         B b(s.rdbuf(), new std::codecvt_utf8<wchar_t>);
         assert(b.rdbuf() == s.rdbuf());
-        assert(new_called != 0);
+        COUNT_NEW_ASSERT(new_called != 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
         std::stringstream s;
         B b(s.rdbuf(), new std::codecvt_utf8<wchar_t>, std::mbstate_t());
         assert(b.rdbuf() == s.rdbuf());
-        assert(new_called != 0);
+        COUNT_NEW_ASSERT(new_called != 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
 }

test/localization/locales/locale/locale.cons/default.pass.cpp

 
 // locale() throw();
 
-// UNSUPPORTED: asan, msan
-
 #include <locale>
-#include <new>
 #include <cassert>
 
 #include "platform_support.h" // locale name macros
-
-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"
 
 void check(const std::locale& loc)
 {

     int ok;
     {
         std::locale loc;
-        assert(new_called == 0);
+        COUNT_NEW_ASSERT(new_called == 0);
         assert(loc.name() == "C");
-        assert(new_called == 0);
+        COUNT_NEW_ASSERT(new_called == 0);
         check(loc);
-        assert(new_called == 0);
+        COUNT_NEW_ASSERT(new_called == 0);
         assert(std::locale::global(std::locale(LOCALE_en_US_UTF_8)) == loc);
         ok = new_called;
         std::locale loc2;
-        assert(new_called == ok);
+        COUNT_NEW_ASSERT(new_called == ok);
         check(loc2);
-        assert(new_called == ok);
+        COUNT_NEW_ASSERT(new_called == ok);
         assert(loc2 == std::locale(LOCALE_en_US_UTF_8));
-        assert(new_called == ok);
+        COUNT_NEW_ASSERT(new_called == ok);
     }
-    assert(new_called == ok);
+    COUNT_NEW_ASSERT(new_called == ok);
 }

test/localization/locales/locale/locale.members/combine.pass.cpp

 
 // template <class Facet> locale combine(const locale& other) const;
 
-// UNSUPPORTED: asan, msan
-
 #include <locale>
-#include <new>
 #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"
 
 void check(const std::locale& loc)
 {

         const my_facet& f = std::use_facet<my_facet>(loc3);
         assert(f.test() == 5);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
 }
 {
     {

         {
         }
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
 }
 }

test/support/count_new.hpp

+#ifndef COUNT_NEW_HPP
+#define COUNT_NEW_HPP
+
+# include <cstdlib>
+# include <cassert>
+# include <new>
+
+int new_called = 0;
+int delete_called = 0;
+int last_new_size = 0;
+
+int new_array_called = 0;
+int delete_array_called = 0;
+int last_new_array_size = 0;
+
+#if  !__has_feature(address_sanitizer) \
+  && !__has_feature(memory_sanitizer)
+
+#define COUNT_NEW_ASSERT(Pred) assert(Pred)
+
+void* operator new(std::size_t s) throw(std::bad_alloc)
+{
+    ++new_called;
+    last_new_size = s;
+    return std::malloc(s);
+}
+
+void  operator delete(void* p) throw()
+{
+    ++delete_called;
+    --new_called;
+    std::free(p);
+}
+
+
+void* operator new[](std::size_t s) throw(std::bad_alloc)
+{
+    ++new_array_called;
+    last_new_array_size = s;
+    return operator new(s);
+}
+
+
+void operator delete[](void* p) throw()
+{
+    --new_array_called;
+    ++delete_array_called;
+    operator delete(p);
+}
+
+
+#else
+
+#define COUNT_NEW_ASSERT(Pred) ((void)0)
+
+#endif // __has_feature(sanitizer)
+
+#endif /* COUNT_NEW_HPP */

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp

 // 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = A(2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    COUNT_NEW_ASSERT(new_called == 2);
     assert(f1.target<A>()->id() == 1);
     assert(f2.target<A>()->id() == 2);
     swap(f1, f2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    COUNT_NEW_ASSERT(new_called == 2);
     assert(f1.target<A>()->id() == 2);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = g;
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     swap(f1, f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = A(1);
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     swap(f1, f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = h;
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(*f1.target<int(*)(int)>() == g);
     assert(*f2.target<int(*)(int)>() == h);
     swap(f1, f2);
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(*f1.target<int(*)(int)>() == h);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp

 
 // 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = (int (*)(int))0;
     assert(!f);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int (A::*)(int) const>() != 0);
     }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

 //         && 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f;
     f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f;
     f = g;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f;
     f = (int (*)(int))0;
     assert(!f);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     }

     std::function<int(const A*, int)> f;
     f = &A::foo;
     assert(f);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int (A::*)(int) const>() != 0);
     }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp

 
 // 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 2);
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f2.target<int(*)(int)>() == 0);
     assert(f2.target<A>() == 0);
     }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp

 
 // 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
 {

 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp

 
 // 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 2);
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     std::function<int(int)> f2 = f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     std::function<int(int)> f2 = f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f2.target<int(*)(int)>() == 0);
     assert(f2.target<A>() == 0);
     }
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     assert(!f);
     std::function<long(int)> g = f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(g.target<long(*)(int)>() == 0);
     assert(g.target<A>() == 0);
     assert(!g);
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp

 
 // 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 2);
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     std::function<int(int)> f2;
     f2 = f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f2.target<int(*)(int)>());
     assert(f2.target<A>() == 0);
     }
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);
     std::function<int(int)> f2;
     f2 = f;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f2.target<int(*)(int)>() == 0);
     assert(f2.target<A>() == 0);
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 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);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f2.target<A>());
     assert(f2.target<int(*)(int)>() == 0);
     assert(f.target<A>() == 0);

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp

 
 // 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f.target<A>());
     f = nullptr;
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<A>() == 0);
     }
     {
     std::function<int(int)> f = g;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>());
     assert(f.target<A>() == 0);
     f = nullptr;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(f.target<int(*)(int)>() == 0);
     }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp

 
 // 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
 {

 
 int main()
 {
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = A(2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    COUNT_NEW_ASSERT(new_called == 2);
     assert(f1.target<A>()->id() == 1);
     assert(f2.target<A>()->id() == 2);
     f1.swap(f2);
     assert(A::count == 2);
-    assert(new_called == 2);
+    COUNT_NEW_ASSERT(new_called == 2);
     assert(f1.target<A>()->id() == 2);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = g;
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     f1.swap(f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = A(1);
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(*f1.target<int(*)(int)>() == g);
     assert(f2.target<A>()->id() == 1);
     f1.swap(f2);
     assert(A::count == 1);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(f1.target<A>()->id() == 1);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     {
     std::function<int(int)> f1 = g;
     std::function<int(int)> f2 = h;
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(*f1.target<int(*)(int)>() == g);
     assert(*f2.target<int(*)(int)>() == h);
     f1.swap(f2);
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(*f1.target<int(*)(int)>() == h);
     assert(*f2.target<int(*)(int)>() == g);
     }
     assert(A::count == 0);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
 }

test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

 // allocator:
 // pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
 
-// UNSUPPORTED: asan, msan
-
 #include <memory>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    assert(s == 3 * sizeof(int));
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 int A_constructed = 0;
 

     std::allocator<A> a;
     assert(new_called == 0);
     assert(A_constructed == 0);
+    last_new_size = 0;
     A* ap = a.allocate(3);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
+    COUNT_NEW_ASSERT(last_new_size == 3 * sizeof(int));
     assert(A_constructed == 0);
     a.deallocate(ap, 3);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(A_constructed == 0);
 
+    last_new_size = 0;
     A* ap2 = a.allocate(3, (const void*)5);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
+    COUNT_NEW_ASSERT(last_new_size == 3 * sizeof(int));
     assert(A_constructed == 0);
     a.deallocate(ap2, 3);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(A_constructed == 0);
 }

test/utilities/memory/default.allocator/allocator.members/construct.pass.cpp

 // allocator:
 // template <class... Args> void construct(pointer p, Args&&... args);
 
-// UNSUPPORTED: asan, msan
-
 #include <memory>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_called = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_called;
-    assert(s == 3 * sizeof(int));
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    --new_called;
-    std::free(p);
-}
+#include "count_new.hpp"
 
 int A_constructed = 0;
 

 {
     {
     std::allocator<A> a;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(A_constructed == 0);
 
+    last_new_size = 0;
     A* ap = a.allocate(3);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
+    COUNT_NEW_ASSERT(last_new_size == 3 * sizeof(int));
     assert(A_constructed == 0);
 
     a.construct(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 1);
 
     a.destroy(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 0);
 
     a.construct(ap, A());
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 1);
 
     a.destroy(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 0);
 
     a.construct(ap, 5);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 1);
 
     a.destroy(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 0);
 
     a.construct(ap, 5, (int*)0);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 1);
 
     a.destroy(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(A_constructed == 0);
 
     a.deallocate(ap, 3);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(A_constructed == 0);
     }
     {
     std::allocator<move_only> a;
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(move_only_constructed == 0);
 
+    last_new_size = 0;
     move_only* ap = a.allocate(3);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
+    COUNT_NEW_ASSERT(last_new_size == 3 * sizeof(int));
     assert(move_only_constructed == 0);
 
     a.construct(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(move_only_constructed == 1);
 
     a.destroy(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(move_only_constructed == 0);
 
     a.construct(ap, move_only());
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(move_only_constructed == 1);
 
     a.destroy(ap);
-    assert(new_called == 1);
+    COUNT_NEW_ASSERT(new_called == 1);
     assert(move_only_constructed == 0);
 
     a.deallocate(ap, 3);
-    assert(new_called == 0);
+    COUNT_NEW_ASSERT(new_called == 0);
     assert(move_only_constructed == 0);
     }
 }

test/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp

 
 // template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
 
-// UNSUPPORTED: asan, msan
-
 #include <memory>
-#include <new>
-#include <cstdlib>
 #include <cassert>
 
-int new_count = 0;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    ++new_count;
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
+#include "count_new.hpp"
 
 struct A
 {

 
 int main()
 {
-    int nc = new_count;
+    int nc = new_called;
     {
     int i = 67;
     char c = 'e';
     std::shared_ptr<A> p = std::make_shared<A>(i, c);
-    assert(new_count == nc+1);
+    COUNT_NEW_ASSERT(new_called == nc+1);
     assert(A::count == 1);
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    nc = new_count;
+    nc = new_called;
     {
     char c = 'e';
     std::shared_ptr<A> p = std::make_shared<A>(67, c);
-    assert(new_count == nc+1);
+    COUNT_NEW_ASSERT(new_called == nc+1);
     assert(A::count == 1);
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');