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
This commit is contained in:
Eric Fiselier
2016-06-22 04:51:07 +00:00
parent 770c6885af
commit d61ea34a58
5 changed files with 94 additions and 153 deletions

View File

@@ -7,31 +7,18 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <memory> // <memory>
// template<class Y> explicit shared_ptr(auto_ptr<Y>&& r); // template<class Y> explicit shared_ptr(auto_ptr<Y>&& r);
// UNSUPPORTED: sanitizer-new-delete
#include <memory> #include <memory>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include <cassert> #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 struct B
{ {
@@ -59,47 +46,51 @@ int A::count = 0;
int main() int main()
{ {
{ {
std::auto_ptr<A> ptr(new A); std::auto_ptr<A> ptr(new A);
A* raw_ptr = ptr.get(); 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);
#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::shared_ptr<B> p(std::move(ptr)); std::shared_ptr<B> p(std::move(ptr));
#else #else
std::shared_ptr<B> p(ptr); std::shared_ptr<B> p(ptr);
#endif #endif
assert(false);
}
catch (...)
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(ptr.get() == raw_ptr); assert(p.use_count() == 1);
#else assert(p.get() == raw_ptr);
// Without rvalue references, ptr got copied into assert(ptr.get() == 0);
// 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(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
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)
} }

View File

@@ -8,18 +8,22 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// UNSUPPORTED: sanitizer-new-delete
// <memory> // <memory>
// shared_ptr // shared_ptr
// template<class D> shared_ptr(nullptr_t, D d); // template<class D> shared_ptr(nullptr_t, D d);
// UNSUPPORTED: sanitizer-new-delete
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h"
#include "count_new.hpp"
#include "../test_deleter.h" #include "../test_deleter.h"
struct A struct A
@@ -33,23 +37,10 @@ struct A
int A::count = 0; 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() int main()
{ {
throw_next = true; globalMemCounter.throw_after = 0;
try try
{ {
std::shared_ptr<A> p(nullptr, test_deleter<A>(3)); std::shared_ptr<A> p(nullptr, test_deleter<A>(3));

View File

@@ -8,18 +8,20 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// UNSUPPORTED: sanitizer-new-delete
// <memory> // <memory>
// shared_ptr // shared_ptr
// template<class Y, class D> shared_ptr(Y* p, D d); // template<class Y, class D> shared_ptr(Y* p, D d);
// UNSUPPORTED: sanitizer-new-delete
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include "count_new.hpp"
#include "../test_deleter.h" #include "../test_deleter.h"
struct A struct A
@@ -33,24 +35,10 @@ struct A
int A::count = 0; 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() int main()
{ {
A* ptr = new A; A* ptr = new A;
throw_next = true; globalMemCounter.throw_after = 0;
try try
{ {
std::shared_ptr<A> p(ptr, test_deleter<A>(3)); 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>::count == 0);
assert(test_deleter<A>::dealloc_count == 1); assert(test_deleter<A>::dealloc_count == 1);
} }
assert(globalMemCounter.checkOutstandingNewEq(0));
} }

View File

@@ -8,17 +8,20 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// UNSUPPORTED: sanitizer-new-delete
// <memory> // <memory>
// template<class Y> explicit shared_ptr(Y* p); // template<class Y> explicit shared_ptr(Y* p);
// UNSUPPORTED: sanitizer-new-delete
#include <memory> #include <memory>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "count_new.hpp"
struct A struct A
{ {
static int count; static int count;
@@ -30,26 +33,12 @@ struct A
int A::count = 0; 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() int main()
{ {
{
A* ptr = new A; A* ptr = new A;
throw_next = true;
assert(A::count == 1); assert(A::count == 1);
globalMemCounter.throw_after = 0;
try try
{ {
std::shared_ptr<A> p(ptr); std::shared_ptr<A> p(ptr);
@@ -59,5 +48,5 @@ int main()
{ {
assert(A::count == 0); assert(A::count == 0);
} }
} assert(globalMemCounter.checkOutstandingNewEq(0));
} }

View File

@@ -8,32 +8,19 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// UNSUPPORTED: sanitizer-new-delete
// <memory> // <memory>
// template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r); // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);
// UNSUPPORTED: sanitizer-new-delete
#include <memory> #include <memory>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #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 struct B
{ {
@@ -67,52 +54,46 @@ void assert_deleter ( T * ) { assert(false); }
int main() int main()
{ {
{ {
std::unique_ptr<A> ptr(new A); std::unique_ptr<A> ptr(new A);
A* raw_ptr = ptr.get(); 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::shared_ptr<B> p(std::move(ptr)); std::shared_ptr<B> p(std::move(ptr));
assert(false);
}
catch (...)
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(ptr.get() == raw_ptr); assert(p.use_count() == 1);
#else assert(p.get() == raw_ptr);
assert(A::count == 0);
assert(B::count == 0);
assert(ptr.get() == 0); assert(ptr.get() == 0);
#endif
}
} }
assert(A::count == 0); assert(A::count == 0);
// LWG 2399
{ {
throw_next = false; std::unique_ptr<A> ptr(new A);
fn(std::unique_ptr<int>(new int)); 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 #if TEST_STD_VER >= 14
// LWG 2415 { // LWG 2415
{ std::unique_ptr<int, void (*)(int*)> p(nullptr, assert_deleter<int>);
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
std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
} }
#endif #endif
} }