1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <memory>
11
12// unique_ptr
13
14// test reset
15
16#include <memory>
17#include <cassert>
18
19#include "test_macros.h"
20#include "unique_ptr_test_helper.h"
21
22template <bool IsArray>
23void test_reset_pointer() {
24  typedef typename std::conditional<IsArray, A[], A>::type VT;
25  const int expect_alive = IsArray ? 3 : 1;
26#if TEST_STD_VER >= 11
27  {
28    using U = std::unique_ptr<VT>;
29    U u; ((void)u);
30    ASSERT_NOEXCEPT(u.reset((A*)nullptr));
31  }
32#endif
33  {
34    std::unique_ptr<VT> p(newValue<VT>(expect_alive));
35    assert(A::count == expect_alive);
36    A* i = p.get();
37    assert(i != nullptr);
38    A* new_value = newValue<VT>(expect_alive);
39    assert(A::count == (expect_alive * 2));
40    p.reset(new_value);
41    assert(A::count == expect_alive);
42    assert(p.get() == new_value);
43  }
44  assert(A::count == 0);
45  {
46    std::unique_ptr<const VT> p(newValue<const VT>(expect_alive));
47    assert(A::count == expect_alive);
48    const A* i = p.get();
49    assert(i != nullptr);
50    A* new_value = newValue<VT>(expect_alive);
51    assert(A::count == (expect_alive * 2));
52    p.reset(new_value);
53    assert(A::count == expect_alive);
54    assert(p.get() == new_value);
55  }
56  assert(A::count == 0);
57}
58
59template <bool IsArray>
60void test_reset_nullptr() {
61  typedef typename std::conditional<IsArray, A[], A>::type VT;
62  const int expect_alive = IsArray ? 3 : 1;
63#if TEST_STD_VER >= 11
64  {
65    using U = std::unique_ptr<VT>;
66    U u; ((void)u);
67    ASSERT_NOEXCEPT(u.reset(nullptr));
68  }
69#endif
70  {
71    std::unique_ptr<VT> p(newValue<VT>(expect_alive));
72    assert(A::count == expect_alive);
73    A* i = p.get();
74    assert(i != nullptr);
75    p.reset(nullptr);
76    assert(A::count == 0);
77    assert(p.get() == nullptr);
78  }
79  assert(A::count == 0);
80}
81
82
83template <bool IsArray>
84void test_reset_no_arg() {
85  typedef typename std::conditional<IsArray, A[], A>::type VT;
86  const int expect_alive = IsArray ? 3 : 1;
87#if TEST_STD_VER >= 11
88  {
89    using U = std::unique_ptr<VT>;
90    U u; ((void)u);
91    ASSERT_NOEXCEPT(u.reset());
92  }
93#endif
94  {
95    std::unique_ptr<VT> p(newValue<VT>(expect_alive));
96    assert(A::count == expect_alive);
97    A* i = p.get();
98    assert(i != nullptr);
99    p.reset();
100    assert(A::count == 0);
101    assert(p.get() == nullptr);
102  }
103  assert(A::count == 0);
104}
105
106int main() {
107  {
108    test_reset_pointer</*IsArray*/ false>();
109    test_reset_nullptr<false>();
110    test_reset_no_arg<false>();
111  }
112  {
113    test_reset_pointer</*IsArray*/true>();
114    test_reset_nullptr<true>();
115    test_reset_no_arg<true>();
116  }
117}
118