replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make shared_ptr constructor tests use count_new.hpp 

llvm-svn: 273379
This commit is contained in:
Eric Fiselier 2016-06-22 04:51:07 +00:00
parent d1691c7026
commit 74480010dc
5 changed files with 94 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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
{
@ -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)
}

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

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

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

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

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

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

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

@ -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
{
@ -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
{
throw_next = false;
{ // LWG 2399
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
}