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
XX25 explicit X( int v ): v_( v )
26 {
27 }
28
~XX29 ~X()
30 {
31 v_ = 0;
32 }
33 };
34
share_ownership(P1 const & p1,P2 const & p2)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
main()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