1 | |
2 | // weak_ptr_alias_test.cpp |
3 | // |
4 | // Copyright 2007, 2019 Peter Dimov |
5 | // |
6 | // Distributed under the Boost Software License, Version 1.0. (See |
7 | // accompanying file LICENSE_1_0.txt or copy at |
8 | // http://www.boost.org/LICENSE_1_0.txt) |
9 | |
10 | |
11 | #include <boost/core/lightweight_test.hpp> |
12 | #include <boost/weak_ptr.hpp> |
13 | #include <boost/shared_ptr.hpp> |
14 | #include <memory> |
15 | #include <cstddef> |
16 | |
17 | // |
18 | |
19 | class incomplete; |
20 | |
21 | struct X |
22 | { |
23 | int v_; |
24 | |
25 | explicit X( int v ): v_( v ) |
26 | { |
27 | } |
28 | |
29 | ~X() |
30 | { |
31 | v_ = 0; |
32 | } |
33 | }; |
34 | |
35 | template<class P1, class P2> bool share_ownership( P1 const& p1, P2 const& p2 ) |
36 | { |
37 | return !p1.owner_before( p2 ) && !p2.owner_before( p1 ); |
38 | } |
39 | |
40 | int main() |
41 | { |
42 | { |
43 | boost::shared_ptr<double> p( new double ); |
44 | |
45 | float m = 0; |
46 | boost::weak_ptr<float> p2( p, &m ); |
47 | |
48 | BOOST_TEST( p2.use_count() == p.use_count() ); |
49 | BOOST_TEST( share_ownership( p, p2 ) ); |
50 | BOOST_TEST( p2.lock().get() == &m ); |
51 | |
52 | { |
53 | int m2 = 0; |
54 | boost::weak_ptr<int> p3( p2, &m2 ); |
55 | |
56 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
57 | BOOST_TEST( share_ownership( p2, p3 ) ); |
58 | BOOST_TEST( p3.lock().get() == &m2 ); |
59 | } |
60 | |
61 | { |
62 | int m2 = 0; |
63 | boost::weak_ptr<int const> p3( p, &m2 ); |
64 | |
65 | BOOST_TEST( p3.use_count() == p.use_count() ); |
66 | BOOST_TEST( share_ownership( p, p3 ) ); |
67 | BOOST_TEST( p3.lock().get() == &m2 ); |
68 | } |
69 | |
70 | { |
71 | int m2 = 0; |
72 | boost::weak_ptr<int volatile> p3( p2, &m2 ); |
73 | |
74 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
75 | BOOST_TEST( share_ownership( p2, p3 ) ); |
76 | BOOST_TEST( p3.lock().get() == &m2 ); |
77 | } |
78 | |
79 | { |
80 | int m2 = 0; |
81 | boost::weak_ptr<void> p3( p, &m2 ); |
82 | |
83 | BOOST_TEST( p3.use_count() == p.use_count() ); |
84 | BOOST_TEST( share_ownership( p, p3 ) ); |
85 | BOOST_TEST( p3.lock().get() == &m2 ); |
86 | } |
87 | |
88 | { |
89 | int m2 = 0; |
90 | boost::weak_ptr<void> p3( p2, &m2 ); |
91 | |
92 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
93 | BOOST_TEST( share_ownership( p2, p3 ) ); |
94 | BOOST_TEST( p3.lock().get() == &m2 ); |
95 | } |
96 | |
97 | { |
98 | int m2 = 0; |
99 | boost::weak_ptr<void const volatile> p3( p, &m2 ); |
100 | |
101 | BOOST_TEST( p3.use_count() == p.use_count() ); |
102 | BOOST_TEST( share_ownership( p, p3 ) ); |
103 | BOOST_TEST( p3.lock().get() == &m2 ); |
104 | } |
105 | |
106 | { |
107 | int m2 = 0; |
108 | boost::weak_ptr<void const volatile> p3( p2, &m2 ); |
109 | |
110 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
111 | BOOST_TEST( share_ownership( p2, p3 ) ); |
112 | BOOST_TEST( p3.lock().get() == &m2 ); |
113 | } |
114 | } |
115 | |
116 | { |
117 | boost::shared_ptr<incomplete> p; |
118 | |
119 | float m = 0; |
120 | boost::weak_ptr<float> p2( p, &m ); |
121 | |
122 | BOOST_TEST( p2.use_count() == p.use_count() ); |
123 | BOOST_TEST( share_ownership( p, p2 ) ); |
124 | |
125 | { |
126 | int m2 = 0; |
127 | boost::weak_ptr<int> p3( p2, &m2 ); |
128 | |
129 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
130 | BOOST_TEST( share_ownership( p2, p3 ) ); |
131 | BOOST_TEST( p3.lock().get() == 0 ); |
132 | } |
133 | |
134 | { |
135 | int m2 = 0; |
136 | boost::weak_ptr<int const> p3( p, &m2 ); |
137 | |
138 | BOOST_TEST( p3.use_count() == p.use_count() ); |
139 | BOOST_TEST( share_ownership( p, p3 ) ); |
140 | BOOST_TEST( p3.lock().get() == 0 ); |
141 | } |
142 | |
143 | { |
144 | int m2 = 0; |
145 | boost::weak_ptr<int volatile> p3( p2, &m2 ); |
146 | |
147 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
148 | BOOST_TEST( share_ownership( p2, p3 ) ); |
149 | BOOST_TEST( p3.lock().get() == 0 ); |
150 | } |
151 | |
152 | { |
153 | int m2 = 0; |
154 | boost::weak_ptr<void> p3( p, &m2 ); |
155 | |
156 | BOOST_TEST( p3.use_count() == p.use_count() ); |
157 | BOOST_TEST( share_ownership( p, p3 ) ); |
158 | BOOST_TEST( p3.lock().get() == 0 ); |
159 | } |
160 | |
161 | { |
162 | int m2 = 0; |
163 | boost::weak_ptr<void> p3( p2, &m2 ); |
164 | |
165 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
166 | BOOST_TEST( share_ownership( p2, p3 ) ); |
167 | BOOST_TEST( p3.lock().get() == 0 ); |
168 | } |
169 | |
170 | { |
171 | int m2 = 0; |
172 | boost::weak_ptr<void const volatile> p3( p, &m2 ); |
173 | |
174 | BOOST_TEST( p3.use_count() == p.use_count() ); |
175 | BOOST_TEST( share_ownership( p, p3 ) ); |
176 | BOOST_TEST( p3.lock().get() == 0 ); |
177 | } |
178 | |
179 | { |
180 | int m2 = 0; |
181 | boost::weak_ptr<void const volatile> p3( p2, &m2 ); |
182 | |
183 | BOOST_TEST( p3.use_count() == p2.use_count() ); |
184 | BOOST_TEST( share_ownership( p2, p3 ) ); |
185 | BOOST_TEST( p3.lock().get() == 0 ); |
186 | } |
187 | } |
188 | |
189 | { |
190 | boost::shared_ptr<X> p( new X( 5 ) ); |
191 | |
192 | boost::weak_ptr<int const> p2( p, &p->v_ ); |
193 | |
194 | BOOST_TEST( p2.use_count() == p.use_count() ); |
195 | BOOST_TEST( share_ownership( p, p2 ) ); |
196 | BOOST_TEST( p2.lock().get() == &p->v_ ); |
197 | |
198 | p.reset(); |
199 | BOOST_TEST( p2.expired() ); |
200 | } |
201 | |
202 | return boost::report_errors(); |
203 | } |
204 | |