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

Go to the source code of this file.

Functions

 TEST_CASE ("comparison operators between valid throwing::unique_ptr", "[unique_ptr][comparison]")
 
 TEST_CASE ("comparison operators between valid throwing::unique_ptr and " "std::unique_ptr", "[unique_ptr][comparison]")
 
 TEST_CASE ("comparison operators between valid throwing::unique_ptr and " "std::unique_ptr (other way)", "[unique_ptr][comparison]")
 
 TEST_CASE ("comparison operators with null throwing::unique_ptr", "[unique_ptr][comparison]")
 

Function Documentation

◆ TEST_CASE() [1/4]

TEST_CASE ( "comparison operators between valid throwing::unique_ptr"  ,
""  [unique_ptr][comparison] 
)

Definition at line 16 of file unique_ptr_comparison.cpp.

17  {
18  int *ptr1 = new int;
19  int *ptr2 = new int;
20  auto t_ptr1 = throwing::unique_ptr<int>(ptr1);
21  auto t_ptr1_1 = throwing::unique_ptr<int, NullDeleter>(ptr1);
22  auto t_ptr2 = throwing::unique_ptr<int>(ptr2);
23 
24  REQUIRE_FALSE(t_ptr1 == t_ptr2);
25  REQUIRE(t_ptr1 == t_ptr1);
26  REQUIRE(t_ptr1 == t_ptr1_1);
27 
28  REQUIRE(t_ptr1 != t_ptr2);
29  REQUIRE(t_ptr1_1 != t_ptr2);
30  REQUIRE_FALSE(t_ptr1 != t_ptr1);
31  REQUIRE_FALSE(t_ptr1 != t_ptr1_1);
32 
33  REQUIRE((t_ptr1 < t_ptr2) == (ptr1 < ptr2));
34  REQUIRE((t_ptr1_1 < t_ptr2) == (ptr1 < ptr2));
35  REQUIRE_FALSE(t_ptr1 < t_ptr1);
36  REQUIRE_FALSE(t_ptr1 < t_ptr1_1);
37 
38  REQUIRE((t_ptr1 > t_ptr2) == (ptr1 > ptr2));
39  REQUIRE((t_ptr1_1 > t_ptr2) == (ptr1 > ptr2));
40  REQUIRE_FALSE(t_ptr1 > t_ptr1);
41  REQUIRE_FALSE(t_ptr1 > t_ptr1_1);
42 
43  REQUIRE((t_ptr1 <= t_ptr2) == (ptr1 <= ptr2));
44  REQUIRE((t_ptr1_1 <= t_ptr2) == (ptr1 <= ptr2));
45  REQUIRE((t_ptr1 <= t_ptr1) == (ptr1 <= ptr1));
46  REQUIRE((t_ptr1 <= t_ptr1_1) == (ptr1 <= ptr1));
47 
48  REQUIRE((t_ptr1 >= t_ptr2) == (ptr1 >= ptr2));
49  REQUIRE((t_ptr1_1 >= t_ptr2) == (ptr1 >= ptr2));
50  REQUIRE((t_ptr1 >= t_ptr1) == (ptr1 >= ptr1));
51  REQUIRE((t_ptr1 >= t_ptr1_1) == (ptr1 >= ptr1));
52 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [2/4]

TEST_CASE ( "comparison operators between valid throwing::unique_ptr and " "std::unique_ptr"  ,
""  [unique_ptr][comparison] 
)

Definition at line 54 of file unique_ptr_comparison.cpp.

56  {
57  int *ptr1 = new int;
58  int *ptr2 = new int;
59  auto t_ptr1 = std::unique_ptr<int>(ptr1);
60  auto t_ptr1_1 = std::unique_ptr<int, NullDeleter>(ptr1);
61  auto t_ptr2 = throwing::unique_ptr<int>(ptr2);
62 
63  REQUIRE_FALSE(t_ptr1 == t_ptr2);
64  REQUIRE(t_ptr1 == t_ptr1);
65  REQUIRE(t_ptr1 == t_ptr1_1);
66 
67  REQUIRE(t_ptr1 != t_ptr2);
68  REQUIRE(t_ptr1_1 != t_ptr2);
69  REQUIRE_FALSE(t_ptr1 != t_ptr1);
70  REQUIRE_FALSE(t_ptr1 != t_ptr1_1);
71 
72  REQUIRE((t_ptr1 < t_ptr2) == (ptr1 < ptr2));
73  REQUIRE((t_ptr1_1 < t_ptr2) == (ptr1 < ptr2));
74  REQUIRE_FALSE(t_ptr1 < t_ptr1);
75  REQUIRE_FALSE(t_ptr1 < t_ptr1_1);
76 
77  REQUIRE((t_ptr1 > t_ptr2) == (ptr1 > ptr2));
78  REQUIRE((t_ptr1_1 > t_ptr2) == (ptr1 > ptr2));
79  REQUIRE_FALSE(t_ptr1 > t_ptr1);
80  REQUIRE_FALSE(t_ptr1 > t_ptr1_1);
81 
82  REQUIRE((t_ptr1 <= t_ptr2) == (ptr1 <= ptr2));
83  REQUIRE((t_ptr1_1 <= t_ptr2) == (ptr1 <= ptr2));
84  REQUIRE((t_ptr1 <= t_ptr1) == (ptr1 <= ptr1));
85  REQUIRE((t_ptr1 <= t_ptr1_1) == (ptr1 <= ptr1));
86 
87  REQUIRE((t_ptr1 >= t_ptr2) == (ptr1 >= ptr2));
88  REQUIRE((t_ptr1_1 >= t_ptr2) == (ptr1 >= ptr2));
89  REQUIRE((t_ptr1 >= t_ptr1) == (ptr1 >= ptr1));
90  REQUIRE((t_ptr1 >= t_ptr1_1) == (ptr1 >= ptr1));
91 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [3/4]

TEST_CASE ( "comparison operators between valid throwing::unique_ptr and " "std::unique_ptr (other way)"  ,
""  [unique_ptr][comparison] 
)

Definition at line 93 of file unique_ptr_comparison.cpp.

95  {
96  int *ptr1 = new int;
97  int *ptr2 = new int;
98  auto t_ptr1 = throwing::unique_ptr<int>(ptr1);
99  auto t_ptr1_1 = throwing::unique_ptr<int, NullDeleter>(ptr1);
100  auto t_ptr2 = std::unique_ptr<int>(ptr2);
101 
102  REQUIRE_FALSE(t_ptr1 == t_ptr2);
103  REQUIRE(t_ptr1 == t_ptr1);
104  REQUIRE(t_ptr1 == t_ptr1_1);
105 
106  REQUIRE(t_ptr1 != t_ptr2);
107  REQUIRE(t_ptr1_1 != t_ptr2);
108  REQUIRE_FALSE(t_ptr1 != t_ptr1);
109  REQUIRE_FALSE(t_ptr1 != t_ptr1_1);
110 
111  REQUIRE((t_ptr1 < t_ptr2) == (ptr1 < ptr2));
112  REQUIRE((t_ptr1_1 < t_ptr2) == (ptr1 < ptr2));
113  REQUIRE_FALSE(t_ptr1 < t_ptr1);
114  REQUIRE_FALSE(t_ptr1 < t_ptr1_1);
115 
116  REQUIRE((t_ptr1 > t_ptr2) == (ptr1 > ptr2));
117  REQUIRE((t_ptr1_1 > t_ptr2) == (ptr1 > ptr2));
118  REQUIRE_FALSE(t_ptr1 > t_ptr1);
119  REQUIRE_FALSE(t_ptr1 > t_ptr1_1);
120 
121  REQUIRE((t_ptr1 <= t_ptr2) == (ptr1 <= ptr2));
122  REQUIRE((t_ptr1_1 <= t_ptr2) == (ptr1 <= ptr2));
123  REQUIRE((t_ptr1 <= t_ptr1) == (ptr1 <= ptr1));
124  REQUIRE((t_ptr1 <= t_ptr1_1) == (ptr1 <= ptr1));
125 
126  REQUIRE((t_ptr1 >= t_ptr2) == (ptr1 >= ptr2));
127  REQUIRE((t_ptr1_1 >= t_ptr2) == (ptr1 >= ptr2));
128  REQUIRE((t_ptr1 >= t_ptr1) == (ptr1 >= ptr1));
129  REQUIRE((t_ptr1 >= t_ptr1_1) == (ptr1 >= ptr1));
130 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38

◆ TEST_CASE() [4/4]

TEST_CASE ( "comparison operators with null throwing::unique_ptr"  ,
""  [unique_ptr][comparison] 
)

Definition at line 132 of file unique_ptr_comparison.cpp.

133  {
134  int *ptr = new int;
135  auto t_ptr = throwing::unique_ptr<int>(ptr);
136  auto empty_t_ptr = throwing::unique_ptr<int>();
137 
138  REQUIRE(empty_t_ptr == nullptr);
139  REQUIRE_FALSE(t_ptr == nullptr);
140  REQUIRE(nullptr == empty_t_ptr);
141  REQUIRE_FALSE(nullptr == t_ptr);
142 
143  REQUIRE_FALSE(empty_t_ptr != nullptr);
144  REQUIRE(t_ptr != nullptr);
145  REQUIRE_FALSE(nullptr != empty_t_ptr);
146  REQUIRE(nullptr != t_ptr);
147 
148  REQUIRE((t_ptr < nullptr) == std::less<int *>()(ptr, nullptr));
149  REQUIRE((empty_t_ptr < nullptr) == std::less<int *>()(nullptr, nullptr));
150  REQUIRE((nullptr < t_ptr) == std::less<int *>()(nullptr, ptr));
151  REQUIRE((nullptr < empty_t_ptr) == std::less<int *>()(nullptr, nullptr));
152 
153  REQUIRE((t_ptr > nullptr) == std::less<int *>()(nullptr, ptr));
154  REQUIRE((empty_t_ptr > nullptr) == std::less<int *>()(nullptr, nullptr));
155  REQUIRE((nullptr > t_ptr) == std::less<int *>()(ptr, nullptr));
156  REQUIRE((nullptr > empty_t_ptr) == std::less<int *>()(nullptr, nullptr));
157 
158  REQUIRE((t_ptr <= nullptr) == !std::less<int *>()(nullptr, ptr));
159  REQUIRE((empty_t_ptr <= nullptr) == !std::less<int *>()(nullptr, nullptr));
160  REQUIRE((nullptr <= t_ptr) == !std::less<int *>()(ptr, nullptr));
161  REQUIRE((nullptr <= empty_t_ptr) == !std::less<int *>()(nullptr, nullptr));
162 
163  REQUIRE((t_ptr >= nullptr) == !std::less<int *>()(ptr, nullptr));
164  REQUIRE((empty_t_ptr >= nullptr) == !std::less<int *>()(nullptr, nullptr));
165  REQUIRE((nullptr >= t_ptr) == !std::less<int *>()(nullptr, ptr));
166  REQUIRE((nullptr >= empty_t_ptr) == !std::less<int *>()(nullptr, nullptr));
167 }
throwing::unique_ptr
unique_ptr that manages a single object
Definition: unique_ptr.hpp:38
Generated by   doxygen 1.8.13