1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // <memory>
10
11 // unique_ptr
12
13 //=============================================================================
14 // TESTING std::unique_ptr::unique_ptr()
15 //
16 // Concerns:
17 // 1 The default constructor works for any default constructible deleter types.
18 // 2 The stored type 'T' is allowed to be incomplete.
19 //
20 // Plan
21 // 1 Default construct unique_ptr's with various deleter types (C-1)
22 // 2 Default construct a unique_ptr with an incomplete element_type and
23 // various deleter types (C-1,2)
24
25 #include <memory>
26 #include <cassert>
27 #include "test_macros.h"
28
29 #include "test_macros.h"
30 #include "deleter_types.h"
31 #include "unique_ptr_test_helper.h"
32
33 #if TEST_STD_VER >= 11
34 TEST_CONSTINIT std::unique_ptr<int> global_static_unique_ptr_single;
35 TEST_CONSTINIT std::unique_ptr<int[]> global_static_unique_ptr_runtime;
36
37 struct NonDefaultDeleter {
38 NonDefaultDeleter() = delete;
operator ()NonDefaultDeleter39 TEST_CONSTEXPR_CXX23 void operator()(void*) const {}
40 };
41 #endif
42
43 template <class ElemType>
test_sfinae()44 TEST_CONSTEXPR_CXX23 void test_sfinae() {
45 #if TEST_STD_VER >= 11
46 { // the constructor does not participate in overload resolution when
47 // the deleter is a pointer type
48 using U = std::unique_ptr<ElemType, void (*)(void*)>;
49 static_assert(!std::is_default_constructible<U>::value, "");
50 }
51 { // the constructor does not participate in overload resolution when
52 // the deleter is not default constructible
53 using Del = CDeleter<ElemType>;
54 using U1 = std::unique_ptr<ElemType, NonDefaultDeleter>;
55 using U2 = std::unique_ptr<ElemType, Del&>;
56 using U3 = std::unique_ptr<ElemType, Del const&>;
57 static_assert(!std::is_default_constructible<U1>::value, "");
58 static_assert(!std::is_default_constructible<U2>::value, "");
59 static_assert(!std::is_default_constructible<U3>::value, "");
60 }
61 #endif
62 }
63
64 template <class ElemType>
test_basic()65 TEST_CONSTEXPR_CXX23 bool test_basic() {
66 #if TEST_STD_VER >= 11
67 {
68 using U1 = std::unique_ptr<ElemType>;
69 using U2 = std::unique_ptr<ElemType, Deleter<ElemType> >;
70 static_assert(std::is_nothrow_default_constructible<U1>::value, "");
71 static_assert(std::is_nothrow_default_constructible<U2>::value, "");
72 }
73 #endif
74 {
75 std::unique_ptr<ElemType> p;
76 assert(p.get() == 0);
77 }
78 {
79 std::unique_ptr<ElemType, NCDeleter<ElemType> > p;
80 assert(p.get() == 0);
81 assert(p.get_deleter().state() == 0);
82 p.get_deleter().set_state(5);
83 assert(p.get_deleter().state() == 5);
84 }
85 {
86 std::unique_ptr<ElemType, DefaultCtorDeleter<ElemType> > p;
87 assert(p.get() == 0);
88 assert(p.get_deleter().state() == 0);
89 }
90
91 return true;
92 }
93
94 DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
95 doIncompleteTypeTest(0);
96 doIncompleteTypeTest<IncompleteType, Deleter<IncompleteType> >(0);
97 } {
98 doIncompleteTypeTest<IncompleteType[]>(0);
99 doIncompleteTypeTest<IncompleteType[], Deleter<IncompleteType[]> >(0);
100 })
101
test()102 TEST_CONSTEXPR_CXX23 bool test() {
103 {
104 test_sfinae<int>();
105 test_basic<int>();
106 }
107 {
108 test_sfinae<int[]>();
109 test_basic<int[]>();
110 }
111
112 return true;
113 }
114
main(int,char **)115 int main(int, char**) {
116 test();
117 #if TEST_STD_VER >= 23
118 static_assert(test());
119 #endif
120
121 return 0;
122 }
123