throwing_ptr
Smart pointers that throw on dereference if null
Functions
unique_ptr_construction.cpp File Reference

Go to the source code of this file.

Functions

 TEST_CASE ("unique_ptr to single object constructor from pointer", "[unique_ptr][single][constructor]")
 
 TEST_CASE ("unique_ptr to single object move constructor", "[unique_ptr][single][constructor]")
 
 TEST_CASE ("unique_ptr to single object move constructor from std::unique_ptr", "[unique_ptr][single][constructor]")
 
 TEST_CASE ("unique_ptr to single object constructor from pointer and non " "reference deleter", "[unique_ptr][single][constructor]")
 
 TEST_CASE ("unique_ptr to single object constructor from pointer and reference " "to deleter", "[unique_ptr][single][constructor]")
 
 TEST_CASE ("unique_ptr to single object constructor from pointer and " "move-reference to deleter", "[unique_ptr][single][constructor]")
 
 TEST_CASE ("unique_ptr to single object constructor from convertible pointer " "and copied deleter", "[unique_ptr][single][constructor]")
 
 TEST_CASE ("unique_ptr to single object constructor from convertible object and " "moved deleter", "[unique_ptr][single][constructor]")
 

Function Documentation

◆ TEST_CASE() [1/8]

TEST_CASE ( "unique_ptr to single object constructor from pointer"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 64 of file unique_ptr_construction.cpp.

65  {
66  int *p = new int;
67  throwing::unique_ptr<int> up(p);
68  REQUIRE(up.get() == p);
69 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [2/8]

TEST_CASE ( "unique_ptr to single object move constructor"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 71 of file unique_ptr_construction.cpp.

72  {
73  int *p = new int;
74  throwing::unique_ptr<int> up(p);
75  throwing::unique_ptr<int> up2(std::move(up));
76  REQUIRE(up2.get() == p);
77 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [3/8]

TEST_CASE ( "unique_ptr to single object move constructor from std::unique_ptr"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 79 of file unique_ptr_construction.cpp.

80  {
81  int *p = new int;
82  std::unique_ptr<int> up(p);
83  throwing::unique_ptr<int> up2(std::move(up));
84  REQUIRE(up2.get() == p);
85 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [4/8]

TEST_CASE ( "unique_ptr to single object constructor from pointer and non " "reference deleter"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 87 of file unique_ptr_construction.cpp.

89  {
90  bool d1_copied = false;
91  bool d1_moved = false;
92  bool d1_called = false;
93  bool ptr1_deleted = false;
94  bool d2_copied = false;
95  bool d2_moved = false;
96  bool d2_called = false;
97  bool ptr2_deleted = false;
98  Deleter d1(&d1_copied, &d1_moved, &d1_called);
99  Deleter d2(&d2_copied, &d2_moved, &d2_called);
100  {
101  std::unique_ptr<Foo, Deleter> foo1(new Foo(ptr1_deleted), d1);
102  throwing::unique_ptr<Foo, Deleter> foo2(new Foo(ptr2_deleted), d2);
103  REQUIRE(foo2.get() != nullptr);
104  REQUIRE(d2_copied == d1_copied);
105  REQUIRE(d2_moved == d1_moved);
106  REQUIRE(d2_called == d1_called);
107  REQUIRE_FALSE(ptr2_deleted);
108  }
109  REQUIRE(d2_copied == d1_copied);
110  REQUIRE(d2_moved == d1_moved);
111  REQUIRE(d2_called == d1_called);
112  REQUIRE(ptr2_deleted);
113 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [5/8]

TEST_CASE ( "unique_ptr to single object constructor from pointer and reference " "to deleter"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 116 of file unique_ptr_construction.cpp.

118  {
119  bool d1_copied = false;
120  bool d1_moved = false;
121  bool d1_called = false;
122  bool ptr1_deleted = false;
123  bool d2_copied = false;
124  bool d2_moved = false;
125  bool d2_called = false;
126  bool ptr2_deleted = false;
127  Deleter d1(&d1_copied, &d1_moved, &d1_called);
128  Deleter d2(&d2_copied, &d2_moved, &d2_called);
129  {
130  std::unique_ptr<Foo, Deleter &> foo1(new Foo(ptr1_deleted), d1);
131  throwing::unique_ptr<Foo, Deleter &> foo2(new Foo(ptr2_deleted), d2);
132  REQUIRE(foo2.get() != nullptr);
133  REQUIRE(d2_copied == d1_copied);
134  REQUIRE(d2_moved == d1_moved);
135  REQUIRE(d2_called == d1_called);
136  REQUIRE_FALSE(ptr2_deleted);
137  }
138  REQUIRE(d2_copied == d1_copied);
139  REQUIRE(d2_moved == d1_moved);
140  REQUIRE(d2_called == d1_called);
141  REQUIRE(ptr2_deleted);
142 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [6/8]

TEST_CASE ( "unique_ptr to single object constructor from pointer and " "move-reference to deleter"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 145 of file unique_ptr_construction.cpp.

147  {
148  bool d1_copied = false;
149  bool d1_moved = false;
150  bool d1_called = false;
151  bool ptr1_deleted = false;
152  bool d2_copied = false;
153  bool d2_moved = false;
154  bool d2_called = false;
155  bool ptr2_deleted = false;
156  Deleter d1(&d1_copied, &d1_moved, &d1_called);
157  Deleter d2(&d2_copied, &d2_moved, &d2_called);
158  {
159  std::unique_ptr<Foo, Deleter> foo1(new Foo(ptr1_deleted),
160  std::move(d1));
161  throwing::unique_ptr<Foo, Deleter> foo2(new Foo(ptr2_deleted),
162  std::move(d2));
163  REQUIRE(foo2.get() != nullptr);
164  REQUIRE(d2_copied == d1_copied);
165  REQUIRE(d2_moved == d1_moved);
166  REQUIRE(d2_called == d1_called);
167  REQUIRE_FALSE(ptr2_deleted);
168  }
169  REQUIRE(d2_copied == d1_copied);
170  REQUIRE(d2_moved == d1_moved);
171  REQUIRE(d2_called == d1_called);
172  REQUIRE(ptr2_deleted);
173 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [7/8]

TEST_CASE ( "unique_ptr to single object constructor from convertible pointer " "and copied deleter"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 175 of file unique_ptr_construction.cpp.

177  {
178  bool d1_copied = false;
179  bool d1_moved = false;
180  bool d1_called = false;
181  bool ptr1_deleted = false;
182  bool d2_copied = false;
183  bool d2_moved = false;
184  bool d2_called = false;
185  bool ptr2_deleted = false;
186  auto clear_all = [&]() {
187  d1_copied = d2_copied = d1_called = d2_called = d1_moved = d2_moved =
188  false;
189  };
190  Deleter d1(&d1_copied, &d1_moved, &d1_called);
191  Deleter d2(&d2_copied, &d2_moved, &d2_called);
192  {
193  std::unique_ptr<Foo, Deleter> sup6a(new Foo(ptr1_deleted), d1);
194  throwing::unique_ptr<Foo, Deleter> tup6a(new Foo(ptr2_deleted), d2);
195  REQUIRE(tup6a.get() != nullptr);
196  REQUIRE(d2_copied == d1_copied);
197  REQUIRE(d2_moved == d1_moved);
198  REQUIRE(d2_called == d1_called);
199  REQUIRE_FALSE(ptr2_deleted);
200  clear_all();
201  {
202  std::unique_ptr<Foo, Deleter> sup6b(std::move(sup6a));
203  REQUIRE(sup6b.get() != nullptr);
204  REQUIRE_FALSE(ptr2_deleted);
205  throwing::unique_ptr<Foo, Deleter> tup6b(std::move(tup6a));
206  REQUIRE(tup6b.get() != nullptr);
207  REQUIRE(d2_copied == d1_copied);
208  REQUIRE(d2_moved == d1_moved);
209  REQUIRE(d2_called == d1_called);
210  REQUIRE_FALSE(ptr2_deleted);
211  clear_all();
212  }
213  REQUIRE(ptr2_deleted);
214  }
215 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [8/8]

TEST_CASE ( "unique_ptr to single object constructor from convertible object and " "moved deleter"  ,
""  [unique_ptr][single][constructor] 
)

Definition at line 218 of file unique_ptr_construction.cpp.

220  {
221  bool d1_copied = false;
222  bool d1_moved = false;
223  bool d1_called = false;
224  bool ptr1_deleted = false;
225  bool d2_copied = false;
226  bool d2_moved = false;
227  bool d2_called = false;
228  bool ptr2_deleted = false;
229  auto clear_all = [&]() {
230  d1_copied = d2_copied = d1_called = d2_called = d1_moved = d2_moved =
231  false;
232  };
233  Deleter d1(&d1_copied, &d1_moved, &d1_called);
234  Deleter d2(&d2_copied, &d2_moved, &d2_called);
235  {
236  std::unique_ptr<Foo, Deleter &> sup6a(new Foo(ptr1_deleted), d1);
237  throwing::unique_ptr<Foo, Deleter &> tup6a(new Foo(ptr2_deleted), d2);
238  REQUIRE(tup6a.get() != nullptr);
239  REQUIRE(d2_copied == d1_copied);
240  REQUIRE(d2_moved == d1_moved);
241  REQUIRE(d2_called == d1_called);
242  REQUIRE_FALSE(ptr2_deleted);
243  clear_all();
244  {
245  std::unique_ptr<Foo, Deleter> sup6b(std::move(sup6a));
246  REQUIRE(sup6b.get() != nullptr);
247  REQUIRE_FALSE(ptr2_deleted);
248 
249  throwing::unique_ptr<Foo, Deleter> tup6b(std::move(tup6a));
250  REQUIRE(tup6b.get() != nullptr);
251  REQUIRE(d2_copied == d1_copied);
252  REQUIRE(d2_moved == d1_moved);
253  REQUIRE(d2_called == d1_called);
254  REQUIRE_FALSE(ptr2_deleted);
255  clear_all();
256  }
257  REQUIRE(ptr2_deleted);
258  }
259 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38
Generated by   doxygen 1.8.13