4727272254
This patch overhauls both specializations of unique_ptr while implementing the following LWG issues: * LWG 2801 - This issue constrains unique_ptr's constructors when the deleter type is not default constructible. Additionally it adds SFINAE conditions to unique_ptr<T[]>::unique_ptr(Up). * LWG 2905 - This issue reworks the unique_ptr(pointer, /* see below */ deleter) constructors so that they correctly SFINAE when the deleter argument cannot be used to construct the stored deleter. * LWG 2520 - This issue fixes initializing unique_ptr<T[]> from nullptr. Libc++ had previously implemented this issue, but the suggested resolution still broke initialization from NULL. This patch re-works the unique_ptr<T[]>(Up, deleter) overloads so that they accept NULL as well as nullptr. llvm-svn: 300406
118 lines
2.8 KiB
C++
118 lines
2.8 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// <memory>
|
|
|
|
// unique_ptr
|
|
|
|
// test reset
|
|
|
|
#include <memory>
|
|
#include <cassert>
|
|
|
|
#include "test_macros.h"
|
|
#include "unique_ptr_test_helper.h"
|
|
|
|
template <bool IsArray>
|
|
void test_reset_pointer() {
|
|
typedef typename std::conditional<IsArray, A[], A>::type VT;
|
|
const int expect_alive = IsArray ? 3 : 1;
|
|
#if TEST_STD_VER >= 11
|
|
{
|
|
using U = std::unique_ptr<VT>;
|
|
U u; ((void)u);
|
|
ASSERT_NOEXCEPT(u.reset((A*)nullptr));
|
|
}
|
|
#endif
|
|
{
|
|
std::unique_ptr<VT> p(newValue<VT>(expect_alive));
|
|
assert(A::count == expect_alive);
|
|
A* i = p.get();
|
|
assert(i != nullptr);
|
|
A* new_value = newValue<VT>(expect_alive);
|
|
assert(A::count == (expect_alive * 2));
|
|
p.reset(new_value);
|
|
assert(A::count == expect_alive);
|
|
assert(p.get() == new_value);
|
|
}
|
|
assert(A::count == 0);
|
|
{
|
|
std::unique_ptr<const VT> p(newValue<const VT>(expect_alive));
|
|
assert(A::count == expect_alive);
|
|
const A* i = p.get();
|
|
assert(i != nullptr);
|
|
A* new_value = newValue<VT>(expect_alive);
|
|
assert(A::count == (expect_alive * 2));
|
|
p.reset(new_value);
|
|
assert(A::count == expect_alive);
|
|
assert(p.get() == new_value);
|
|
}
|
|
assert(A::count == 0);
|
|
}
|
|
|
|
template <bool IsArray>
|
|
void test_reset_nullptr() {
|
|
typedef typename std::conditional<IsArray, A[], A>::type VT;
|
|
const int expect_alive = IsArray ? 3 : 1;
|
|
#if TEST_STD_VER >= 11
|
|
{
|
|
using U = std::unique_ptr<VT>;
|
|
U u; ((void)u);
|
|
ASSERT_NOEXCEPT(u.reset(nullptr));
|
|
}
|
|
#endif
|
|
{
|
|
std::unique_ptr<VT> p(newValue<VT>(expect_alive));
|
|
assert(A::count == expect_alive);
|
|
A* i = p.get();
|
|
assert(i != nullptr);
|
|
p.reset(nullptr);
|
|
assert(A::count == 0);
|
|
assert(p.get() == nullptr);
|
|
}
|
|
assert(A::count == 0);
|
|
}
|
|
|
|
|
|
template <bool IsArray>
|
|
void test_reset_no_arg() {
|
|
typedef typename std::conditional<IsArray, A[], A>::type VT;
|
|
const int expect_alive = IsArray ? 3 : 1;
|
|
#if TEST_STD_VER >= 11
|
|
{
|
|
using U = std::unique_ptr<VT>;
|
|
U u; ((void)u);
|
|
ASSERT_NOEXCEPT(u.reset());
|
|
}
|
|
#endif
|
|
{
|
|
std::unique_ptr<VT> p(newValue<VT>(expect_alive));
|
|
assert(A::count == expect_alive);
|
|
A* i = p.get();
|
|
assert(i != nullptr);
|
|
p.reset();
|
|
assert(A::count == 0);
|
|
assert(p.get() == nullptr);
|
|
}
|
|
assert(A::count == 0);
|
|
}
|
|
|
|
int main() {
|
|
{
|
|
test_reset_pointer</*IsArray*/ false>();
|
|
test_reset_nullptr<false>();
|
|
test_reset_no_arg<false>();
|
|
}
|
|
{
|
|
test_reset_pointer</*IsArray*/true>();
|
|
test_reset_nullptr<true>();
|
|
test_reset_no_arg<true>();
|
|
}
|
|
}
|