Make shared_ptr constructor tests use count_new.hpp

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@273379 91177308-0d34-0410-b5e6-96231b3b80d8

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;
-
-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);
-}
+#include "test_macros.h"
+#include "count_new.hpp"
 
 struct B
 {
@@ -59,47 +46,51 @@ int A::count = 0;
 int main()
 {
     {
-    std::auto_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    std::shared_ptr<B> p(std::move(ptr));
-#else
-    std::shared_ptr<B> p(ptr);
-#endif
-    assert(A::count == 1);
-    assert(B::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == raw_ptr);
-    assert(ptr.get() == 0);
-    }
-    assert(A::count == 0);
-    {
-    std::auto_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-    throw_next = true;
-    try
-    {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+        std::auto_ptr<A> ptr(new A);
+        A* raw_ptr = ptr.get();
+#if TEST_STD_VER >= 11
         std::shared_ptr<B> p(std::move(ptr));
 #else
         std::shared_ptr<B> p(ptr);
 #endif
-        assert(false);
-    }
-    catch (...)
-    {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(A::count == 1);
         assert(B::count == 1);
-        assert(ptr.get() == raw_ptr);
+        assert(p.use_count() == 1);
+        assert(p.get() == raw_ptr);
+        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();
+        globalMemCounter.throw_after = 0;
+        try
+        {
+#if TEST_STD_VER >= 11
+            std::shared_ptr<B> p(std::move(ptr));
 #else
-        // Without rvalue references, ptr got copied into
-        // the shared_ptr destructor and the copy was
-        // destroyed during unwinding.
-        assert(A::count == 0);
-        assert(B::count == 0);
+            std::shared_ptr<B> p(ptr);
 #endif
-    }
+            assert(false);
+        }
+        catch (...)
+        {
+#if TEST_STD_VER >= 11
+            assert(A::count == 1);
+            assert(B::count == 1);
+            assert(ptr.get() == raw_ptr);
+ #else
+            // Without rvalue references, ptr got copied into
+            // the shared_ptr destructor and the copy was
+            // destroyed during unwinding.
+            assert(A::count == 0);
+            assert(B::count == 0);
+#endif
+        }
     }
     assert(A::count == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
+#endif // !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
 }

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));

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));
 }

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));
 }

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"
-
-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);
-}
+#include "count_new.hpp"
 
 struct B
 {
@@ -67,52 +54,46 @@ void assert_deleter ( T * ) { assert(false); }
 int main()
 {
     {
-    std::unique_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-    std::shared_ptr<B> p(std::move(ptr));
-    assert(A::count == 1);
-    assert(B::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == raw_ptr);
-    assert(ptr.get() == 0);
-    }
-    assert(A::count == 0);
-    {
-    std::unique_ptr<A> ptr(new A);
-    A* raw_ptr = ptr.get();
-    throw_next = true;
-    try
-    {
+        std::unique_ptr<A> ptr(new A);
+        A* raw_ptr = ptr.get();
         std::shared_ptr<B> p(std::move(ptr));
-        assert(false);
-    }
-    catch (...)
-    {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(A::count == 1);
         assert(B::count == 1);
-        assert(ptr.get() == raw_ptr);
-#else
-        assert(A::count == 0);
-        assert(B::count == 0);
+        assert(p.use_count() == 1);
+        assert(p.get() == raw_ptr);
         assert(ptr.get() == 0);
-#endif
-    }
     }
     assert(A::count == 0);
-
-    // LWG 2399
     {
-    throw_next = false;
-    fn(std::unique_ptr<int>(new int));
+        std::unique_ptr<A> ptr(new A);
+        A* raw_ptr = ptr.get();
+        globalMemCounter.throw_after = 0;
+        try
+        {
+            std::shared_ptr<B> p(std::move(ptr));
+            assert(false);
+        }
+        catch (...)
+        {
+#if TEST_STD_VER >= 11
+            assert(A::count == 1);
+            assert(B::count == 1);
+            assert(ptr.get() == raw_ptr);
+#else
+            assert(A::count == 0);
+            assert(B::count == 0);
+            assert(ptr.get() == 0);
+#endif
+        }
+    }
+    assert(A::count == 0);
+    { // LWG 2399
+        fn(std::unique_ptr<int>(new int));
     }
-
 #if TEST_STD_VER >= 14
-    // 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
+    { // 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
-
 }