test_smart_ptr.cpp 18.6 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
/*
Dean Moldovan's avatar
Dean Moldovan committed
2
    tests/test_smart_ptr.cpp -- binding classes with custom reference counting,
3
    implicit conversions between types
Wenzel Jakob's avatar
Wenzel Jakob committed
4

5
    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Wenzel Jakob's avatar
Wenzel Jakob committed
6
7
8
9
10

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

11
12
#if defined(_MSC_VER) && _MSC_VER < 1910 // VS 2015's MSVC
#    pragma warning(disable : 4702)      // unreachable code in system header (xatomic.h(382))
13
14
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
15
#include "object.h"
16
#include "pybind11_tests.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
17

18
namespace {
Wenzel Jakob's avatar
Wenzel Jakob committed
19

20
// This is just a wrapper around unique_ptr, but with extra fields to deliberately bloat up the
21
22
23
24
// holder size to trigger the non-simple-layout internal instance layout for single inheritance
// with large holder type:
template <typename T>
class huge_unique_ptr {
25
26
    std::unique_ptr<T> ptr;
    uint64_t padding[10];
27

28
public:
29
    explicit huge_unique_ptr(T *p) : ptr(p) {}
30
31
    T *get() { return ptr.get(); }
};
32

33
34
35
36
// Simple custom holder that works like unique_ptr
template <typename T>
class custom_unique_ptr {
    std::unique_ptr<T> impl;
37

38
public:
39
    explicit custom_unique_ptr(T *p) : impl(p) {}
40
41
    T *get() const { return impl.get(); }
    T *release_ptr() { return impl.release(); }
42
};
43

44
45
46
47
48
49
// Simple custom holder that works like shared_ptr and has operator& overload
// To obtain address of an instance of this holder pybind should use std::addressof
// Attempt to get address via operator& may leads to segmentation fault
template <typename T>
class shared_ptr_with_addressof_operator {
    std::shared_ptr<T> impl;
50

51
public:
52
    shared_ptr_with_addressof_operator() = default;
53
    explicit shared_ptr_with_addressof_operator(T *p) : impl(p) {}
54
55
    T *get() const { return impl.get(); }
    T **operator&() { throw std::logic_error("Call of overloaded operator& is not expected"); }
56
57
58
59
60
61
62
63
};

// Simple custom holder that works like unique_ptr and has operator& overload
// To obtain address of an instance of this holder pybind should use std::addressof
// Attempt to get address via operator& may leads to segmentation fault
template <typename T>
class unique_ptr_with_addressof_operator {
    std::unique_ptr<T> impl;
64

65
66
public:
    unique_ptr_with_addressof_operator() = default;
67
    explicit unique_ptr_with_addressof_operator(T *p) : impl(p) {}
68
69
70
    T *get() const { return impl.get(); }
    T *release_ptr() { return impl.release(); }
    T **operator&() { throw std::logic_error("Call of overloaded operator& is not expected"); }
71
72
};

73
74
75
// Custom object with builtin reference counting (see 'object.h' for the implementation)
class MyObject1 : public Object {
public:
76
    explicit MyObject1(int value) : value(value) { print_created(this, toString()); }
77
    std::string toString() const override { return "MyObject1[" + std::to_string(value) + "]"; }
78

79
80
protected:
    ~MyObject1() override { print_destroyed(this); }
81

82
83
84
85
86
87
88
89
private:
    int value;
};

// Object managed by a std::shared_ptr<>
class MyObject2 {
public:
    MyObject2(const MyObject2 &) = default;
90
    explicit MyObject2(int value) : value(value) { print_created(this, toString()); }
91
92
    std::string toString() const { return "MyObject2[" + std::to_string(value) + "]"; }
    virtual ~MyObject2() { print_destroyed(this); }
93

94
95
96
97
98
99
100
101
private:
    int value;
};

// Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<>
class MyObject3 : public std::enable_shared_from_this<MyObject3> {
public:
    MyObject3(const MyObject3 &) = default;
102
    explicit MyObject3(int value) : value(value) { print_created(this, toString()); }
103
104
    std::string toString() const { return "MyObject3[" + std::to_string(value) + "]"; }
    virtual ~MyObject3() { print_destroyed(this); }
105

106
107
108
109
110
111
112
private:
    int value;
};

// test_unique_nodelete
// Object with a private destructor
class MyObject4;
113
std::unordered_set<MyObject4 *> myobject4_instances;
114
115
class MyObject4 {
public:
116
    explicit MyObject4(int value) : value{value} {
117
118
119
120
121
122
123
124
        print_created(this);
        myobject4_instances.insert(this);
    }
    int value;

    static void cleanupAllInstances() {
        auto tmp = std::move(myobject4_instances);
        myobject4_instances.clear();
125
        for (auto *o : tmp) {
126
            delete o;
127
        }
128
    }
129

130
131
132
133
134
135
136
137
138
139
140
private:
    ~MyObject4() {
        myobject4_instances.erase(this);
        print_destroyed(this);
    }
};

// test_unique_deleter
// Object with std::unique_ptr<T, D> where D is not matching the base class
// Object with a protected destructor
class MyObject4a;
141
std::unordered_set<MyObject4a *> myobject4a_instances;
142
143
class MyObject4a {
public:
144
    explicit MyObject4a(int i) : value{i} {
145
146
147
148
149
150
151
152
        print_created(this);
        myobject4a_instances.insert(this);
    };
    int value;

    static void cleanupAllInstances() {
        auto tmp = std::move(myobject4a_instances);
        myobject4a_instances.clear();
153
        for (auto *o : tmp) {
154
            delete o;
155
        }
156
    }
157

158
159
160
161
162
163
164
165
166
167
protected:
    virtual ~MyObject4a() {
        myobject4a_instances.erase(this);
        print_destroyed(this);
    }
};

// Object derived but with public destructor and no Deleter in default holder
class MyObject4b : public MyObject4a {
public:
168
    explicit MyObject4b(int i) : MyObject4a(i) { print_created(this); }
169
170
171
172
173
174
    ~MyObject4b() override { print_destroyed(this); }
};

// test_large_holder
class MyObject5 { // managed by huge_unique_ptr
public:
175
    explicit MyObject5(int value) : value{value} { print_created(this); }
176
177
178
179
180
181
182
183
184
    ~MyObject5() { print_destroyed(this); }
    int value;
};

// test_shared_ptr_and_references
struct SharedPtrRef {
    struct A {
        A() { print_created(this); }
        A(const A &) { print_copy_created(this); }
185
        A(A &&) noexcept { print_move_created(this); }
186
187
188
189
190
191
192
193
194
195
196
        ~A() { print_destroyed(this); }
    };

    A value = {};
    std::shared_ptr<A> shared = std::make_shared<A>();
};

// test_shared_ptr_from_this_and_references
struct SharedFromThisRef {
    struct B : std::enable_shared_from_this<B> {
        B() { print_created(this); }
197
        // NOLINTNEXTLINE(bugprone-copy-constructor-init)
198
        B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); }
199
        B(B &&) noexcept : std::enable_shared_from_this<B>() { print_move_created(this); }
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
        ~B() { print_destroyed(this); }
    };

    B value = {};
    std::shared_ptr<B> shared = std::make_shared<B>();
};

// Issue #865: shared_from_this doesn't work with virtual inheritance
struct SharedFromThisVBase : std::enable_shared_from_this<SharedFromThisVBase> {
    SharedFromThisVBase() = default;
    SharedFromThisVBase(const SharedFromThisVBase &) = default;
    virtual ~SharedFromThisVBase() = default;
};
struct SharedFromThisVirt : virtual SharedFromThisVBase {};

// test_move_only_holder
struct C {
    C() { print_created(this); }
    ~C() { print_destroyed(this); }
};

// test_holder_with_addressof_operator
struct TypeForHolderWithAddressOf {
    TypeForHolderWithAddressOf() { print_created(this); }
    TypeForHolderWithAddressOf(const TypeForHolderWithAddressOf &) { print_copy_created(this); }
225
226
227
    TypeForHolderWithAddressOf(TypeForHolderWithAddressOf &&) noexcept {
        print_move_created(this);
    }
228
229
230
231
232
233
234
235
236
    ~TypeForHolderWithAddressOf() { print_destroyed(this); }
    std::string toString() const {
        return "TypeForHolderWithAddressOf[" + std::to_string(value) + "]";
    }
    int value = 42;
};

// test_move_only_holder_with_addressof_operator
struct TypeForMoveOnlyHolderWithAddressOf {
237
    explicit TypeForMoveOnlyHolderWithAddressOf(int value) : value{value} { print_created(this); }
238
239
240
241
242
243
244
245
    ~TypeForMoveOnlyHolderWithAddressOf() { print_destroyed(this); }
    std::string toString() const {
        return "MoveOnlyHolderWithAddressOf[" + std::to_string(value) + "]";
    }
    int value;
};

// test_smart_ptr_from_default
246
struct HeldByDefaultHolder {};
247
248
249
250
251
252

// test_shared_ptr_gc
// #187: issue involving std::shared_ptr<> return value policy & garbage collection
struct ElementBase {
    virtual ~ElementBase() = default; /* Force creation of virtual table */
    ElementBase() = default;
253
    ElementBase(const ElementBase &) = delete;
254
255
256
};

struct ElementA : ElementBase {
257
    explicit ElementA(int v) : v(v) {}
258
    int value() const { return v; }
259
260
261
262
    int v;
};

struct ElementList {
263
    void add(const std::shared_ptr<ElementBase> &e) { l.push_back(e); }
264
265
266
267
268
269
270
271
272
    std::vector<std::shared_ptr<ElementBase>> l;
};

} // namespace

// ref<T> is a wrapper for 'Object' which uses intrusive reference counting
// It is always possible to construct a ref<T> from an Object* pointer without
// possible inconsistencies, hence the 'true' argument at the end.
// Make pybind11 aware of the non-standard getter member function
273
274
275
276
277
278
namespace pybind11 {
namespace detail {
template <typename T>
struct holder_helper<ref<T>> {
    static const T *get(const ref<T> &p) { return p.get_ptr(); }
};
279
280
281
282
283
284
285
286
287
288
289
} // namespace detail
} // namespace pybind11

// Make pybind aware of the ref-counted wrapper type (s):
PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true);
// The following is not required anymore for std::shared_ptr, but it should compile without error:
PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>);
PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>);
PYBIND11_DECLARE_HOLDER_TYPE(T, shared_ptr_with_addressof_operator<T>);
PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator<T>);
290

291
TEST_SUBMODULE(smart_ptr, m) {
292
293
294
    // Please do not interleave `struct` and `class` definitions with bindings code,
    // but implement `struct`s and `class`es in the anonymous namespace above.
    // This helps keeping the smart_holder branch in sync with master.
295

296
    // test_smart_ptr
297

298
    // Object implementation in `object.h`
Wenzel Jakob's avatar
Wenzel Jakob committed
299
300
301
    py::class_<Object, ref<Object>> obj(m, "Object");
    obj.def("getRefCount", &Object::getRefCount);

302
    py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj).def(py::init<int>());
303
    py::implicitly_convertible<py::int_, MyObject1>();
Wenzel Jakob's avatar
Wenzel Jakob committed
304

305
    m.def("make_object_1", []() -> Object * { return new MyObject1(1); });
306
    m.def("make_object_2", []() -> ref<Object> { return ref<Object>(new MyObject1(2)); });
307
    m.def("make_myobject1_1", []() -> MyObject1 * { return new MyObject1(4); });
308
    m.def("make_myobject1_2", []() -> ref<MyObject1> { return ref<MyObject1>(new MyObject1(5)); });
309
310
311
312
313
314
315
316
317
318
319
    m.def("print_object_1", [](const Object *obj) { py::print(obj->toString()); });
    m.def("print_object_2", [](ref<Object> obj) { py::print(obj->toString()); });
    m.def("print_object_3", [](const ref<Object> &obj) { py::print(obj->toString()); });
    m.def("print_object_4", [](const ref<Object> *obj) { py::print((*obj)->toString()); });
    m.def("print_myobject1_1", [](const MyObject1 *obj) { py::print(obj->toString()); });
    m.def("print_myobject1_2", [](ref<MyObject1> obj) { py::print(obj->toString()); });
    m.def("print_myobject1_3", [](const ref<MyObject1> &obj) { py::print(obj->toString()); });
    m.def("print_myobject1_4", [](const ref<MyObject1> *obj) { py::print((*obj)->toString()); });

    // Expose constructor stats for the ref type
    m.def("cstats_ref", &ConstructorStats::get<ref_tag>);
320

321
    py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2").def(py::init<int>());
322
323
324
    m.def("make_myobject2_1", []() { return new MyObject2(6); });
    m.def("make_myobject2_2", []() { return std::make_shared<MyObject2>(7); });
    m.def("print_myobject2_1", [](const MyObject2 *obj) { py::print(obj->toString()); });
325
    // NOLINTNEXTLINE(performance-unnecessary-value-param)
326
    m.def("print_myobject2_2", [](std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); });
327
328
329
330
    m.def("print_myobject2_3",
          [](const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); });
    m.def("print_myobject2_4",
          [](const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); });
331

332
    py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3").def(py::init<int>());
333
334
335
    m.def("make_myobject3_1", []() { return new MyObject3(8); });
    m.def("make_myobject3_2", []() { return std::make_shared<MyObject3>(9); });
    m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); });
336
    // NOLINTNEXTLINE(performance-unnecessary-value-param)
337
    m.def("print_myobject3_2", [](std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); });
338
339
340
341
    m.def("print_myobject3_3",
          [](const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); });
    m.def("print_myobject3_4",
          [](const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); });
342
343
344

    // test_smart_ptr_refcounting
    m.def("test_object1_refcounting", []() {
345
        auto o = ref<MyObject1>(new MyObject1(0));
346
347
348
349
350
351
352
353
354
        bool good = o->getRefCount() == 1;
        py::object o2 = py::cast(o, py::return_value_policy::reference);
        // always request (partial) ownership for objects with intrusive
        // reference counting even when using the 'reference' RVP
        good &= o->getRefCount() == 2;
        return good;
    });

    // test_unique_nodelete
355
356
    py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4")
        .def(py::init<int>())
357
358
        .def_readwrite("value", &MyObject4::value)
        .def_static("cleanup_all_instances", &MyObject4::cleanupAllInstances);
359

360
361
362
    // test_unique_deleter
    py::class_<MyObject4a, std::unique_ptr<MyObject4a, py::nodelete>>(m, "MyObject4a")
        .def(py::init<int>())
363
364
        .def_readwrite("value", &MyObject4a::value)
        .def_static("cleanup_all_instances", &MyObject4a::cleanupAllInstances);
365

366
    py::class_<MyObject4b, MyObject4a, std::unique_ptr<MyObject4b>>(m, "MyObject4b")
367
368
        .def(py::init<int>());

369
    // test_large_holder
370
371
372
373
    py::class_<MyObject5, huge_unique_ptr<MyObject5>>(m, "MyObject5")
        .def(py::init<int>())
        .def_readwrite("value", &MyObject5::value);

374
    // test_shared_ptr_and_references
375
376
    using A = SharedPtrRef::A;
    py::class_<A, std::shared_ptr<A>>(m, "A");
377
    py::class_<SharedPtrRef, std::unique_ptr<SharedPtrRef>>(m, "SharedPtrRef")
378
379
        .def(py::init<>())
        .def_readonly("ref", &SharedPtrRef::value)
380
381
        .def_property_readonly(
            "copy", [](const SharedPtrRef &s) { return s.value; }, py::return_value_policy::copy)
382
        .def_readonly("holder_ref", &SharedPtrRef::shared)
383
384
385
386
        .def_property_readonly(
            "holder_copy",
            [](const SharedPtrRef &s) { return s.shared; },
            py::return_value_policy::copy)
387
        .def("set_ref", [](SharedPtrRef &, const A &) { return true; })
388
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
389
390
        .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; });

391
    // test_shared_ptr_from_this_and_references
392
393
    using B = SharedFromThisRef::B;
    py::class_<B, std::shared_ptr<B>>(m, "B");
394
    py::class_<SharedFromThisRef, std::unique_ptr<SharedFromThisRef>>(m, "SharedFromThisRef")
395
396
        .def(py::init<>())
        .def_readonly("bad_wp", &SharedFromThisRef::value)
397
398
399
400
401
402
        .def_property_readonly("ref",
                               [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
        .def_property_readonly(
            "copy",
            [](const SharedFromThisRef &s) { return s.value; },
            py::return_value_policy::copy)
403
        .def_readonly("holder_ref", &SharedFromThisRef::shared)
404
405
406
407
        .def_property_readonly(
            "holder_copy",
            [](const SharedFromThisRef &s) { return s.shared; },
            py::return_value_policy::copy)
408
        .def("set_ref", [](SharedFromThisRef &, const B &) { return true; })
409
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
410
        .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; });
411

412
413
414
415
416
    // Issue #865: shared_from_this doesn't work with virtual inheritance
    static std::shared_ptr<SharedFromThisVirt> sft(new SharedFromThisVirt());
    py::class_<SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>>(m, "SharedFromThisVirt")
        .def_static("get", []() { return sft.get(); });

417
418
    // test_move_only_holder
    py::class_<C, custom_unique_ptr<C>>(m, "TypeWithMoveOnlyHolder")
419
420
        .def_static("make", []() { return custom_unique_ptr<C>(new C); })
        .def_static("make_as_object", []() { return py::cast(custom_unique_ptr<C>(new C)); });
421

422
423
424
425
426
    // test_holder_with_addressof_operator
    using HolderWithAddressOf = shared_ptr_with_addressof_operator<TypeForHolderWithAddressOf>;
    py::class_<TypeForHolderWithAddressOf, HolderWithAddressOf>(m, "TypeForHolderWithAddressOf")
        .def_static("make", []() { return HolderWithAddressOf(new TypeForHolderWithAddressOf); })
        .def("get", [](const HolderWithAddressOf &self) { return self.get(); })
427
428
429
        .def("print_object_1",
             [](const TypeForHolderWithAddressOf *obj) { py::print(obj->toString()); })
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
430
        .def("print_object_2", [](HolderWithAddressOf obj) { py::print(obj.get()->toString()); })
431
432
433
434
        .def("print_object_3",
             [](const HolderWithAddressOf &obj) { py::print(obj.get()->toString()); })
        .def("print_object_4",
             [](const HolderWithAddressOf *obj) { py::print((*obj).get()->toString()); });
435
436

    // test_move_only_holder_with_addressof_operator
437
438
439
440
441
442
443
444
445
    using MoveOnlyHolderWithAddressOf
        = unique_ptr_with_addressof_operator<TypeForMoveOnlyHolderWithAddressOf>;
    py::class_<TypeForMoveOnlyHolderWithAddressOf, MoveOnlyHolderWithAddressOf>(
        m, "TypeForMoveOnlyHolderWithAddressOf")
        .def_static("make",
                    []() {
                        return MoveOnlyHolderWithAddressOf(
                            new TypeForMoveOnlyHolderWithAddressOf(0));
                    })
446
        .def_readwrite("value", &TypeForMoveOnlyHolderWithAddressOf::value)
447
448
        .def("print_object",
             [](const TypeForMoveOnlyHolderWithAddressOf *obj) { py::print(obj->toString()); });
449

450
    // test_smart_ptr_from_default
451
    py::class_<HeldByDefaultHolder, std::unique_ptr<HeldByDefaultHolder>>(m, "HeldByDefaultHolder")
452
        .def(py::init<>())
453
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
454
        .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {});
455

456
    // test_shared_ptr_gc
457
458
459
460
461
462
463
464
465
466
467
468
    // #187: issue involving std::shared_ptr<> return value policy & garbage collection
    py::class_<ElementBase, std::shared_ptr<ElementBase>>(m, "ElementBase");

    py::class_<ElementA, ElementBase, std::shared_ptr<ElementA>>(m, "ElementA")
        .def(py::init<int>())
        .def("value", &ElementA::value);

    py::class_<ElementList, std::shared_ptr<ElementList>>(m, "ElementList")
        .def(py::init<>())
        .def("add", &ElementList::add)
        .def("get", [](ElementList &el) {
            py::list list;
469
            for (auto &e : el.l) {
470
                list.append(py::cast(e));
471
            }
472
473
            return list;
        });
474
}