Make shared_ptr constructor tests use count_new.hpp

llvm-svn: 273379

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

@@ -7,31 +7,18 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template<class Y> explicit shared_ptr(auto_ptr<Y>&& r);
 
-// UNSUPPORTED: sanitizer-new-delete
 
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 
-bool throw_next = false;
+#include "test_macros.h"
-
+#include "count_new.hpp"
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
 
 struct B
 {
@@ -61,7 +48,7 @@ int main()
     {
         std::auto_ptr<A> ptr(new A);
         A* raw_ptr = ptr.get();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
         std::shared_ptr<B> p(std::move(ptr));
 #else
         std::shared_ptr<B> p(ptr);
@@ -73,13 +60,15 @@ int main()
         assert(ptr.get() == 0);
     }
     assert(A::count == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+#if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
     {
         std::auto_ptr<A> ptr(new A);
         A* raw_ptr = ptr.get();
-    throw_next = true;
+        globalMemCounter.throw_after = 0;
         try
         {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
             std::shared_ptr<B> p(std::move(ptr));
 #else
             std::shared_ptr<B> p(ptr);
@@ -88,7 +77,7 @@ int main()
         }
         catch (...)
         {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
             assert(A::count == 1);
             assert(B::count == 1);
             assert(ptr.get() == raw_ptr);
@@ -102,4 +91,6 @@ int main()
         }
     }
     assert(A::count == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+#endif // !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
 }

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

@@ -8,18 +8,22 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // shared_ptr
 
 // template<class D> shared_ptr(nullptr_t, D d);
 
-// UNSUPPORTED: sanitizer-new-delete
-
 #include <memory>
 #include <cassert>
 #include <new>
 #include <cstdlib>
+
+#include "test_macros.h"
+#include "count_new.hpp"
+
 #include "../test_deleter.h"
 
 struct A
@@ -33,23 +37,10 @@ struct A
 
 int A::count = 0;
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
 
 int main()
 {
-    throw_next = true;
+    globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(nullptr, test_deleter<A>(3));

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

@@ -8,18 +8,20 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // shared_ptr
 
 // template<class Y, class D> shared_ptr(Y* p, D d);
 
-// UNSUPPORTED: sanitizer-new-delete
-
 #include <memory>
 #include <cassert>
 #include <new>
 #include <cstdlib>
+
+#include "count_new.hpp"
 #include "../test_deleter.h"
 
 struct A
@@ -33,24 +35,10 @@ struct A
 
 int A::count = 0;
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
-
 int main()
 {
     A* ptr = new A;
-    throw_next = true;
+    globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(ptr, test_deleter<A>(3));
@@ -62,4 +50,5 @@ int main()
         assert(test_deleter<A>::count == 0);
         assert(test_deleter<A>::dealloc_count == 1);
     }
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }

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

@@ -8,17 +8,20 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // template<class Y> explicit shared_ptr(Y* p);
 
-// UNSUPPORTED: sanitizer-new-delete
 
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 
+#include "count_new.hpp"
+
 struct A
 {
     static int count;
@@ -30,26 +33,12 @@ struct A
 
 int A::count = 0;
 
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
 
 int main()
-{
 {
     A* ptr = new A;
-    throw_next = true;
     assert(A::count == 1);
+    globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(ptr);
@@ -59,5 +48,5 @@ int main()
     {
         assert(A::count == 0);
     }
-    }
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 }

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

@@ -8,32 +8,19 @@
 //===----------------------------------------------------------------------===//
 
 // XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: sanitizer-new-delete
+
 // <memory>
 
 // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);
 
-// UNSUPPORTED: sanitizer-new-delete
-
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
-
+#include "count_new.hpp"
-bool throw_next = false;
-
-void* operator new(std::size_t s) throw(std::bad_alloc)
-{
-    if (throw_next)
-        throw std::bad_alloc();
-    return std::malloc(s);
-}
-
-void  operator delete(void* p) throw()
-{
-    std::free(p);
-}
 
 struct B
 {
@@ -80,7 +67,7 @@ int main()
     {
         std::unique_ptr<A> ptr(new A);
         A* raw_ptr = ptr.get();
-    throw_next = true;
+        globalMemCounter.throw_after = 0;
         try
         {
             std::shared_ptr<B> p(std::move(ptr));
@@ -88,7 +75,7 @@ int main()
         }
         catch (...)
         {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
             assert(A::count == 1);
             assert(B::count == 1);
             assert(ptr.get() == raw_ptr);
@@ -100,19 +87,13 @@ int main()
         }
     }
     assert(A::count == 0);
-
+    { // LWG 2399
-    // LWG 2399
-    {
-    throw_next = false;
         fn(std::unique_ptr<int>(new int));
     }
-
 #if TEST_STD_VER >= 14
-    // LWG 2415
+    { // LWG 2415
-    {
         std::unique_ptr<int, void (*)(int*)> p(nullptr, assert_deleter<int>);
         std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
     }
 #endif
-
 }