1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // UNSUPPORTED: c++03
10 
11 // <memory>
12 
13 // shared_ptr
14 
15 // shared_ptr& operator=(shared_ptr&& r);
16 
17 #include <memory>
18 #include <type_traits>
19 #include <cassert>
20 
21 #include "test_macros.h"
22 
23 struct B
24 {
25     static int count;
26 
BB27     B() {++count;}
BB28     B(const B&) {++count;}
~BB29     virtual ~B() {--count;}
30 };
31 
32 int B::count = 0;
33 
34 struct A
35     : public B
36 {
37     static int count;
38 
AA39     A() {++count;}
AA40     A(const A& other) : B(other) {++count;}
~AA41     ~A() {--count;}
42 };
43 
44 int A::count = 0;
45 
main(int,char **)46 int main(int, char**)
47 {
48     {
49         std::shared_ptr<A> pA(new A);
50         A* ptrA = pA.get();
51         {
52             std::shared_ptr<A> pB(new A);
53             pB = std::move(pA);
54             assert(B::count == 1);
55             assert(A::count == 1);
56             assert(pB.use_count() == 1);
57             assert(pA.use_count() == 0);
58             assert(pA.get() == 0);
59             assert(pB.get() == ptrA);
60         }
61         assert(pA.use_count() == 0);
62         assert(B::count == 0);
63         assert(A::count == 0);
64     }
65     assert(B::count == 0);
66     assert(A::count == 0);
67     {
68         std::shared_ptr<A> pA;
69         A* ptrA = pA.get();
70         {
71             std::shared_ptr<A> pB(new A);
72             pB = std::move(pA);
73             assert(B::count == 0);
74             assert(A::count == 0);
75             assert(pB.use_count() == 0);
76             assert(pA.use_count() == 0);
77             assert(pA.get() == 0);
78             assert(pB.get() == ptrA);
79         }
80         assert(pA.use_count() == 0);
81         assert(B::count == 0);
82         assert(A::count == 0);
83     }
84     assert(B::count == 0);
85     assert(A::count == 0);
86     {
87         std::shared_ptr<A> pA(new A);
88         A* ptrA = pA.get();
89         {
90             std::shared_ptr<A> pB;
91             pB = std::move(pA);
92             assert(B::count == 1);
93             assert(A::count == 1);
94             assert(pB.use_count() == 1);
95             assert(pA.use_count() == 0);
96             assert(pA.get() == 0);
97             assert(pB.get() == ptrA);
98         }
99         assert(pA.use_count() == 0);
100         assert(B::count == 0);
101         assert(A::count == 0);
102     }
103     assert(B::count == 0);
104     assert(A::count == 0);
105     {
106         std::shared_ptr<A> pA;
107         A* ptrA = pA.get();
108         {
109             std::shared_ptr<A> pB;
110             pB = std::move(pA);
111             assert(B::count == 0);
112             assert(A::count == 0);
113             assert(pB.use_count() == 0);
114             assert(pA.use_count() == 0);
115             assert(pA.get() == 0);
116             assert(pB.get() == ptrA);
117         }
118         assert(pA.use_count() == 0);
119         assert(B::count == 0);
120         assert(A::count == 0);
121     }
122     assert(B::count == 0);
123     assert(A::count == 0);
124 
125   return 0;
126 }
127