test_smart_ptr.py 9.31 KB
Newer Older
1
import pytest
2
3
4

m = pytest.importorskip("pybind11_tests.smart_ptr")
from pybind11_tests import ConstructorStats  # noqa: E402
Dean Moldovan's avatar
Dean Moldovan committed
5
6
7
8


def test_smart_ptr(capture):
    # Object1
9
10
11
    for i, o in enumerate(
        [m.make_object_1(), m.make_object_2(), m.MyObject1(3)], start=1
    ):
Dean Moldovan's avatar
Dean Moldovan committed
12
13
        assert o.getRefCount() == 1
        with capture:
14
15
16
17
            m.print_object_1(o)
            m.print_object_2(o)
            m.print_object_3(o)
            m.print_object_4(o)
18
        assert capture == f"MyObject1[{i}]\n" * 4
Dean Moldovan's avatar
Dean Moldovan committed
19

20
21
22
    for i, o in enumerate(
        [m.make_myobject1_1(), m.make_myobject1_2(), m.MyObject1(6), 7], start=4
    ):
Dean Moldovan's avatar
Dean Moldovan committed
23
24
25
        print(o)
        with capture:
            if not isinstance(o, int):
26
27
28
29
30
31
32
33
                m.print_object_1(o)
                m.print_object_2(o)
                m.print_object_3(o)
                m.print_object_4(o)
            m.print_myobject1_1(o)
            m.print_myobject1_2(o)
            m.print_myobject1_3(o)
            m.print_myobject1_4(o)
34
35

        times = 4 if isinstance(o, int) else 8
36
        assert capture == f"MyObject1[{i}]\n" * times
Dean Moldovan's avatar
Dean Moldovan committed
37

38
    cstats = ConstructorStats.get(m.MyObject1)
Dean Moldovan's avatar
Dean Moldovan committed
39
    assert cstats.alive() == 0
40
    expected_values = [f"MyObject1[{i}]" for i in range(1, 7)] + ["MyObject1[7]"] * 4
Dean Moldovan's avatar
Dean Moldovan committed
41
42
43
44
45
46
47
48
    assert cstats.values() == expected_values
    assert cstats.default_constructions == 0
    assert cstats.copy_constructions == 0
    # assert cstats.move_constructions >= 0 # Doesn't invoke any
    assert cstats.copy_assignments == 0
    assert cstats.move_assignments == 0

    # Object2
49
50
51
    for i, o in zip(
        [8, 6, 7], [m.MyObject2(8), m.make_myobject2_1(), m.make_myobject2_2()]
    ):
Dean Moldovan's avatar
Dean Moldovan committed
52
53
        print(o)
        with capture:
54
55
56
57
            m.print_myobject2_1(o)
            m.print_myobject2_2(o)
            m.print_myobject2_3(o)
            m.print_myobject2_4(o)
58
        assert capture == f"MyObject2[{i}]\n" * 4
Dean Moldovan's avatar
Dean Moldovan committed
59

60
    cstats = ConstructorStats.get(m.MyObject2)
Dean Moldovan's avatar
Dean Moldovan committed
61
62
63
    assert cstats.alive() == 1
    o = None
    assert cstats.alive() == 0
64
    assert cstats.values() == ["MyObject2[8]", "MyObject2[6]", "MyObject2[7]"]
Dean Moldovan's avatar
Dean Moldovan committed
65
66
67
68
69
70
71
    assert cstats.default_constructions == 0
    assert cstats.copy_constructions == 0
    # assert cstats.move_constructions >= 0 # Doesn't invoke any
    assert cstats.copy_assignments == 0
    assert cstats.move_assignments == 0

    # Object3
72
73
74
    for i, o in zip(
        [9, 8, 9], [m.MyObject3(9), m.make_myobject3_1(), m.make_myobject3_2()]
    ):
Dean Moldovan's avatar
Dean Moldovan committed
75
76
        print(o)
        with capture:
77
78
79
80
            m.print_myobject3_1(o)
            m.print_myobject3_2(o)
            m.print_myobject3_3(o)
            m.print_myobject3_4(o)
81
        assert capture == f"MyObject3[{i}]\n" * 4
Dean Moldovan's avatar
Dean Moldovan committed
82

83
    cstats = ConstructorStats.get(m.MyObject3)
Dean Moldovan's avatar
Dean Moldovan committed
84
85
86
    assert cstats.alive() == 1
    o = None
    assert cstats.alive() == 0
87
    assert cstats.values() == ["MyObject3[9]", "MyObject3[8]", "MyObject3[9]"]
Dean Moldovan's avatar
Dean Moldovan committed
88
89
90
91
92
93
    assert cstats.default_constructions == 0
    assert cstats.copy_constructions == 0
    # assert cstats.move_constructions >= 0 # Doesn't invoke any
    assert cstats.copy_assignments == 0
    assert cstats.move_assignments == 0

94
95
    # Object
    cstats = ConstructorStats.get(m.Object)
Dean Moldovan's avatar
Dean Moldovan committed
96
97
98
99
100
101
102
103
    assert cstats.alive() == 0
    assert cstats.values() == []
    assert cstats.default_constructions == 10
    assert cstats.copy_constructions == 0
    # assert cstats.move_constructions >= 0 # Doesn't invoke any
    assert cstats.copy_assignments == 0
    assert cstats.move_assignments == 0

104
105
    # ref<>
    cstats = m.cstats_ref()
Dean Moldovan's avatar
Dean Moldovan committed
106
    assert cstats.alive() == 0
107
    assert cstats.values() == ["from pointer"] * 10
Dean Moldovan's avatar
Dean Moldovan committed
108
109
110
111
112
    assert cstats.default_constructions == 30
    assert cstats.copy_constructions == 12
    # assert cstats.move_constructions >= 0 # Doesn't invoke any
    assert cstats.copy_assignments == 30
    assert cstats.move_assignments == 0
113

114

115
def test_smart_ptr_refcounting():
116
    assert m.test_object1_refcounting()
117
118


119
def test_unique_nodelete():
120
    o = m.MyObject4(23)
121
    assert o.value == 23
122
    cstats = ConstructorStats.get(m.MyObject4)
123
124
    assert cstats.alive() == 1
    del o
125
126
127
    assert cstats.alive() == 1
    m.MyObject4.cleanup_all_instances()
    assert cstats.alive() == 0
128
129


130
131
132
133
134
135
def test_unique_nodelete4a():
    o = m.MyObject4a(23)
    assert o.value == 23
    cstats = ConstructorStats.get(m.MyObject4a)
    assert cstats.alive() == 1
    del o
136
137
138
    assert cstats.alive() == 1
    m.MyObject4a.cleanup_all_instances()
    assert cstats.alive() == 0
139
140
141


def test_unique_deleter():
142
    m.MyObject4a(0)
143
144
145
    o = m.MyObject4b(23)
    assert o.value == 23
    cstats4a = ConstructorStats.get(m.MyObject4a)
146
    assert cstats4a.alive() == 2
147
148
149
    cstats4b = ConstructorStats.get(m.MyObject4b)
    assert cstats4b.alive() == 1
    del o
150
    assert cstats4a.alive() == 1  # Should now only be one leftover
151
    assert cstats4b.alive() == 0  # Should be deleted
152
153
154
    m.MyObject4a.cleanup_all_instances()
    assert cstats4a.alive() == 0
    assert cstats4b.alive() == 0
155
156


157
def test_large_holder():
158
    o = m.MyObject5(5)
159
    assert o.value == 5
160
    cstats = ConstructorStats.get(m.MyObject5)
161
162
163
164
165
    assert cstats.alive() == 1
    del o
    assert cstats.alive() == 0


166
def test_shared_ptr_and_references():
167
168
    s = m.SharedPtrRef()
    stats = ConstructorStats.get(m.A)
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
    assert stats.alive() == 2

    ref = s.ref  # init_holder_helper(holder_ptr=false, owned=false)
    assert stats.alive() == 2
    assert s.set_ref(ref)
    with pytest.raises(RuntimeError) as excinfo:
        assert s.set_holder(ref)
    assert "Unable to cast from non-held to held instance" in str(excinfo.value)

    copy = s.copy  # init_holder_helper(holder_ptr=false, owned=true)
    assert stats.alive() == 3
    assert s.set_ref(copy)
    assert s.set_holder(copy)

    holder_ref = s.holder_ref  # init_holder_helper(holder_ptr=true, owned=false)
    assert stats.alive() == 3
    assert s.set_ref(holder_ref)
    assert s.set_holder(holder_ref)

    holder_copy = s.holder_copy  # init_holder_helper(holder_ptr=true, owned=true)
    assert stats.alive() == 3
    assert s.set_ref(holder_copy)
    assert s.set_holder(holder_copy)

    del ref, copy, holder_ref, holder_copy, s
    assert stats.alive() == 0


def test_shared_ptr_from_this_and_references():
198
199
    s = m.SharedFromThisRef()
    stats = ConstructorStats.get(m.B)
200
201
202
203
204
    assert stats.alive() == 2

    ref = s.ref  # init_holder_helper(holder_ptr=false, owned=false, bad_wp=false)
    assert stats.alive() == 2
    assert s.set_ref(ref)
205
206
207
    assert s.set_holder(
        ref
    )  # std::enable_shared_from_this can create a holder from a reference
208
209
210
211
212
213
214
215
216
217
218
219
220

    bad_wp = s.bad_wp  # init_holder_helper(holder_ptr=false, owned=false, bad_wp=true)
    assert stats.alive() == 2
    assert s.set_ref(bad_wp)
    with pytest.raises(RuntimeError) as excinfo:
        assert s.set_holder(bad_wp)
    assert "Unable to cast from non-held to held instance" in str(excinfo.value)

    copy = s.copy  # init_holder_helper(holder_ptr=false, owned=true, bad_wp=false)
    assert stats.alive() == 3
    assert s.set_ref(copy)
    assert s.set_holder(copy)

221
222
223
    holder_ref = (
        s.holder_ref
    )  # init_holder_helper(holder_ptr=true, owned=false, bad_wp=false)
224
225
226
227
    assert stats.alive() == 3
    assert s.set_ref(holder_ref)
    assert s.set_holder(holder_ref)

228
229
230
    holder_copy = (
        s.holder_copy
    )  # init_holder_helper(holder_ptr=true, owned=true, bad_wp=false)
231
232
233
234
235
236
    assert stats.alive() == 3
    assert s.set_ref(holder_copy)
    assert s.set_holder(holder_copy)

    del ref, bad_wp, copy, holder_ref, holder_copy, s
    assert stats.alive() == 0
237

238
239
    z = m.SharedFromThisVirt.get()
    y = m.SharedFromThisVirt.get()
240
241
    assert y is z

242
243

def test_move_only_holder():
244
    a = m.TypeWithMoveOnlyHolder.make()
245
    b = m.TypeWithMoveOnlyHolder.make_as_object()
246
    stats = ConstructorStats.get(m.TypeWithMoveOnlyHolder)
247
248
    assert stats.alive() == 2
    del b
249
250
251
    assert stats.alive() == 1
    del a
    assert stats.alive() == 0
252
253


254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
def test_holder_with_addressof_operator():
    # this test must not throw exception from c++
    a = m.TypeForHolderWithAddressOf.make()
    a.print_object_1()
    a.print_object_2()
    a.print_object_3()
    a.print_object_4()

    stats = ConstructorStats.get(m.TypeForHolderWithAddressOf)
    assert stats.alive() == 1

    np = m.TypeForHolderWithAddressOf.make()
    assert stats.alive() == 2
    del a
    assert stats.alive() == 1
    del np
    assert stats.alive() == 0

    b = m.TypeForHolderWithAddressOf.make()
    c = b
    assert b.get() is c.get()
    assert stats.alive() == 1

    del b
    assert stats.alive() == 1

    del c
    assert stats.alive() == 0


def test_move_only_holder_with_addressof_operator():
    a = m.TypeForMoveOnlyHolderWithAddressOf.make()
    a.print_object()

    stats = ConstructorStats.get(m.TypeForMoveOnlyHolderWithAddressOf)
    assert stats.alive() == 1

    a.value = 42
    assert a.value == 42

    del a
    assert stats.alive() == 0


298
def test_smart_ptr_from_default():
299
    instance = m.HeldByDefaultHolder()
300
    with pytest.raises(RuntimeError) as excinfo:
301
        m.HeldByDefaultHolder.load_shared_ptr(instance)
302
303
304
305
    assert (
        "Unable to load a custom holder type from a "
        "default-holder instance" in str(excinfo.value)
    )
306
307
308
309


def test_shared_ptr_gc():
    """#187: issue involving std::shared_ptr<> return value policy & garbage collection"""
310
    el = m.ElementList()
311
    for i in range(10):
312
        el.add(m.ElementA(i))
313
314
315
    pytest.gc_collect()
    for i, v in enumerate(el.get()):
        assert i == v.value()