1/*
2Copyright 2019 Glen Joseph Fernandes
3(glenjofe@gmail.com)
4
5Distributed under the Boost Software License, Version 1.0.
6(http://www.boost.org/LICENSE_1_0.txt)
7*/
8#include <boost/config.hpp>
9#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
10 BOOST_LIBSTDCXX_VERSION >= 48000) && \
11 !defined(BOOST_NO_CXX11_SMART_PTR)
12#include <boost/smart_ptr/allocate_unique.hpp>
13#include <boost/core/lightweight_test.hpp>
14
15template<class T = void>
16struct creator {
17 typedef T value_type;
18 typedef T* pointer;
19
20 template<class U>
21 struct rebind {
22 typedef creator<U> other;
23 };
24
25 creator() { }
26
27 template<class U>
28 creator(const creator<U>&) { }
29
30 T* allocate(std::size_t size) {
31 return static_cast<T*>(::operator new(sizeof(T) * size));
32 }
33
34 void deallocate(T* ptr, std::size_t) {
35 ::operator delete(ptr);
36 }
37};
38
39template<class T, class U>
40inline bool
41operator==(const creator<T>&, const creator<U>&)
42{
43 return true;
44}
45
46template<class T, class U>
47inline bool
48operator!=(const creator<T>&, const creator<U>&)
49{
50 return false;
51}
52
53class type {
54public:
55 static unsigned instances;
56
57 type()
58 : value_(0.0) {
59 ++instances;
60 }
61
62 ~type() {
63 --instances;
64 }
65
66 void set(long double value) {
67 value_ = value;
68 }
69
70 long double get() const {
71 return value_;
72 }
73
74private:
75 type(const type&);
76 type& operator=(const type&);
77
78 long double value_;
79};
80
81unsigned type::instances = 0;
82
83int main()
84{
85 {
86 std::unique_ptr<int[],
87 boost::alloc_deleter<int[],
88 boost::noinit_adaptor<creator<int> > > > result =
89 boost::allocate_unique_noinit<int[]>(alloc: creator<int>(), size: 3);
90 BOOST_TEST(result.get() != 0);
91 }
92 {
93 std::unique_ptr<int[],
94 boost::alloc_deleter<int[3],
95 boost::noinit_adaptor<creator<int> > > > result =
96 boost::allocate_unique_noinit<int[3]>(alloc: creator<int>());
97 BOOST_TEST(result.get() != 0);
98 }
99 {
100 std::unique_ptr<int[][2],
101 boost::alloc_deleter<int[][2],
102 boost::noinit_adaptor<creator<> > > > result =
103 boost::allocate_unique_noinit<int[][2]>(alloc: creator<>(), size: 2);
104 BOOST_TEST(result.get() != 0);
105 }
106 {
107 std::unique_ptr<int[][2],
108 boost::alloc_deleter<int[2][2],
109 boost::noinit_adaptor<creator<> > > > result =
110 boost::allocate_unique_noinit<int[2][2]>(alloc: creator<>());
111 BOOST_TEST(result.get() != 0);
112 }
113 {
114 std::unique_ptr<const int[],
115 boost::alloc_deleter<const int[],
116 boost::noinit_adaptor<creator<> > > > result =
117 boost::allocate_unique_noinit<const int[]>(alloc: creator<>(), size: 3);
118 BOOST_TEST(result.get() != 0);
119 }
120 {
121 std::unique_ptr<const int[],
122 boost::alloc_deleter<const int[3],
123 boost::noinit_adaptor<creator<> > > > result =
124 boost::allocate_unique_noinit<const int[3]>(alloc: creator<>());
125 BOOST_TEST(result.get() != 0);
126 }
127 {
128 std::unique_ptr<const int[][2],
129 boost::alloc_deleter<const int[][2],
130 boost::noinit_adaptor<creator<> > > > result =
131 boost::allocate_unique_noinit<const int[][2]>(alloc: creator<>(), size: 2);
132 BOOST_TEST(result.get() != 0);
133 }
134 {
135 std::unique_ptr<const int[][2],
136 boost::alloc_deleter<const int[2][2],
137 boost::noinit_adaptor<creator<> > > > result =
138 boost::allocate_unique_noinit<const int[2][2]>(alloc: creator<>());
139 BOOST_TEST(result.get() != 0);
140 }
141 {
142 std::unique_ptr<type[],
143 boost::alloc_deleter<type[],
144 boost::noinit_adaptor<creator<type> > > > result =
145 boost::allocate_unique_noinit<type[]>(alloc: creator<type>(), size: 3);
146 BOOST_TEST(result.get() != 0);
147 BOOST_TEST(type::instances == 3);
148 result.reset();
149 BOOST_TEST(type::instances == 0);
150 }
151 {
152 std::unique_ptr<type[],
153 boost::alloc_deleter<type[3],
154 boost::noinit_adaptor<creator<type> > > > result =
155 boost::allocate_unique_noinit<type[3]>(alloc: creator<type>());
156 BOOST_TEST(result.get() != 0);
157 BOOST_TEST(type::instances == 3);
158 result.reset();
159 BOOST_TEST(type::instances == 0);
160 }
161 {
162 std::unique_ptr<type[][2],
163 boost::alloc_deleter<type[][2],
164 boost::noinit_adaptor<creator<> > > > result =
165 boost::allocate_unique_noinit<type[][2]>(alloc: creator<>(), size: 2);
166 BOOST_TEST(result.get() != 0);
167 BOOST_TEST(type::instances == 4);
168 result.reset();
169 BOOST_TEST(type::instances == 0);
170 }
171 {
172 std::unique_ptr<type[][2],
173 boost::alloc_deleter<type[2][2],
174 boost::noinit_adaptor<creator<> > > > result =
175 boost::allocate_unique_noinit<type[2][2]>(alloc: creator<>());
176 BOOST_TEST(result.get() != 0);
177 BOOST_TEST(type::instances == 4);
178 result.reset();
179 BOOST_TEST(type::instances == 0);
180 }
181 {
182 std::unique_ptr<const type[],
183 boost::alloc_deleter<const type[],
184 boost::noinit_adaptor<creator<> > > > result =
185 boost::allocate_unique_noinit<const type[]>(alloc: creator<>(), size: 3);
186 BOOST_TEST(result.get() != 0);
187 BOOST_TEST(type::instances == 3);
188 result.reset();
189 BOOST_TEST(type::instances == 0);
190 }
191 {
192 std::unique_ptr<const type[],
193 boost::alloc_deleter<const type[3],
194 boost::noinit_adaptor<creator<> > > > result =
195 boost::allocate_unique_noinit<const type[3]>(alloc: creator<>());
196 BOOST_TEST(result.get() != 0);
197 BOOST_TEST(type::instances == 3);
198 result.reset();
199 BOOST_TEST(type::instances == 0);
200 }
201 {
202 std::unique_ptr<const type[][2],
203 boost::alloc_deleter<const type[][2],
204 boost::noinit_adaptor<creator<> > > > result =
205 boost::allocate_unique_noinit<const type[][2]>(alloc: creator<>(), size: 2);
206 BOOST_TEST(result.get() != 0);
207 BOOST_TEST(type::instances == 4);
208 result.reset();
209 BOOST_TEST(type::instances == 0);
210 }
211 {
212 std::unique_ptr<const type[][2],
213 boost::alloc_deleter<const type[2][2],
214 boost::noinit_adaptor<creator<> > > > result =
215 boost::allocate_unique_noinit<const type[2][2]>(alloc: creator<>());
216 BOOST_TEST(result.get() != 0);
217 BOOST_TEST(type::instances == 4);
218 result.reset();
219 BOOST_TEST(type::instances == 0);
220 }
221 return boost::report_errors();
222}
223#else
224int main()
225{
226 return 0;
227}
228#endif
229

source code of boost/libs/smart_ptr/test/allocate_unique_array_noinit_test.cpp