test_factory_constructors.cpp 16.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
/*
    tests/test_factory_constructors.cpp -- tests construction from a factory function
                                           via py::init_factory()

    Copyright (c) 2017 Jason Rhinelander <jason@imaginary.ca>

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

#include "constructor_stats.h"
12
#include "pybind11_tests.h"
13
#include <cmath>
14
#include <new>
15
#include <utility>
16
17

// Classes for testing python construction via C++ factory function:
Unknown's avatar
Unknown committed
18
// Not publicly constructible, copyable, or movable:
19
20
21
class TestFactory1 {
    friend class TestFactoryHelper;
    TestFactory1() : value("(empty)") { print_default_created(this); }
22
23
24
    explicit TestFactory1(int v) : value(std::to_string(v)) { print_created(this, value); }
    explicit TestFactory1(std::string v) : value(std::move(v)) { print_created(this, value); }

25
26
public:
    std::string value;
27
28
29
30
31
32
33
34
35
36
    TestFactory1(TestFactory1 &&) = delete;
    TestFactory1(const TestFactory1 &) = delete;
    TestFactory1 &operator=(TestFactory1 &&) = delete;
    TestFactory1 &operator=(const TestFactory1 &) = delete;
    ~TestFactory1() { print_destroyed(this); }
};
// Non-public construction, but moveable:
class TestFactory2 {
    friend class TestFactoryHelper;
    TestFactory2() : value("(empty2)") { print_default_created(this); }
37
38
39
    explicit TestFactory2(int v) : value(std::to_string(v)) { print_created(this, value); }
    explicit TestFactory2(std::string v) : value(std::move(v)) { print_created(this, value); }

40
public:
41
42
43
44
45
46
47
48
49
    TestFactory2(TestFactory2 &&m) noexcept {
        value = std::move(m.value);
        print_move_created(this);
    }
    TestFactory2 &operator=(TestFactory2 &&m) noexcept {
        value = std::move(m.value);
        print_move_assigned(this);
        return *this;
    }
50
51
52
53
54
55
56
57
    std::string value;
    ~TestFactory2() { print_destroyed(this); }
};
// Mixed direct/factory construction:
class TestFactory3 {
protected:
    friend class TestFactoryHelper;
    TestFactory3() : value("(empty3)") { print_default_created(this); }
58
59
    explicit TestFactory3(int v) : value(std::to_string(v)) { print_created(this, value); }

60
public:
61
    explicit TestFactory3(std::string v) : value(std::move(v)) { print_created(this, value); }
62
63
64
65
66
67
68
69
70
    TestFactory3(TestFactory3 &&m) noexcept {
        value = std::move(m.value);
        print_move_created(this);
    }
    TestFactory3 &operator=(TestFactory3 &&m) noexcept {
        value = std::move(m.value);
        print_move_assigned(this);
        return *this;
    }
71
72
73
74
75
76
77
    std::string value;
    virtual ~TestFactory3() { print_destroyed(this); }
};
// Inheritance test
class TestFactory4 : public TestFactory3 {
public:
    TestFactory4() : TestFactory3() { print_default_created(this); }
78
    explicit TestFactory4(int v) : TestFactory3(v) { print_created(this, v); }
79
    ~TestFactory4() override { print_destroyed(this); }
80
81
82
83
};
// Another class for an invalid downcast test
class TestFactory5 : public TestFactory3 {
public:
84
    explicit TestFactory5(int i) : TestFactory3(i) { print_created(this, i); }
85
    ~TestFactory5() override { print_destroyed(this); }
86
87
88
89
90
91
92
};

class TestFactory6 {
protected:
    int value;
    bool alias = false;
public:
93
    explicit TestFactory6(int i) : value{i} { print_created(this, i); }
94
95
96
97
98
    TestFactory6(TestFactory6 &&f) noexcept {
        print_move_created(this);
        value = f.value;
        alias = f.alias;
    }
99
100
101
    TestFactory6(const TestFactory6 &f) { print_copy_created(this); value = f.value; alias = f.alias; }
    virtual ~TestFactory6() { print_destroyed(this); }
    virtual int get() { return value; }
102
    bool has_alias() const { return alias; }
103
104
105
106
107
};
class PyTF6 : public TestFactory6 {
public:
    // Special constructor that allows the factory to construct a PyTF6 from a TestFactory6 only
    // when an alias is needed:
108
109
110
111
112
113
114
115
    explicit PyTF6(TestFactory6 &&base) : TestFactory6(std::move(base)) {
        alias = true;
        print_created(this, "move", value);
    }
    explicit PyTF6(int i) : TestFactory6(i) {
        alias = true;
        print_created(this, i);
    }
116
    PyTF6(PyTF6 &&f) noexcept : TestFactory6(std::move(f)) { print_move_created(this); }
117
    PyTF6(const PyTF6 &f) : TestFactory6(f) { print_copy_created(this); }
118
119
120
121
    explicit PyTF6(std::string s) : TestFactory6((int) s.size()) {
        alias = true;
        print_created(this, s);
    }
122
    ~PyTF6() override { print_destroyed(this); }
123
    int get() override { PYBIND11_OVERRIDE(int, TestFactory6, get, /*no args*/); }
124
125
126
127
128
129
130
};

class TestFactory7 {
protected:
    int value;
    bool alias = false;
public:
131
    explicit TestFactory7(int i) : value{i} { print_created(this, i); }
132
133
134
135
136
    TestFactory7(TestFactory7 &&f) noexcept {
        print_move_created(this);
        value = f.value;
        alias = f.alias;
    }
137
138
139
    TestFactory7(const TestFactory7 &f) { print_copy_created(this); value = f.value; alias = f.alias; }
    virtual ~TestFactory7() { print_destroyed(this); }
    virtual int get() { return value; }
140
    bool has_alias() const { return alias; }
141
142
143
};
class PyTF7 : public TestFactory7 {
public:
144
145
146
147
    explicit PyTF7(int i) : TestFactory7(i) {
        alias = true;
        print_created(this, i);
    }
148
    PyTF7(PyTF7 &&f) noexcept : TestFactory7(std::move(f)) { print_move_created(this); }
149
    PyTF7(const PyTF7 &f) : TestFactory7(f) { print_copy_created(this); }
150
    ~PyTF7() override { print_destroyed(this); }
151
    int get() override { PYBIND11_OVERRIDE(int, TestFactory7, get, /*no args*/); }
152
153
154
155
156
157
158
159
160
161
162
};


class TestFactoryHelper {
public:
    // Non-movable, non-copyable type:
    // Return via pointer:
    static TestFactory1 *construct1() { return new TestFactory1(); }
    // Holder:
    static std::unique_ptr<TestFactory1> construct1(int a) { return std::unique_ptr<TestFactory1>(new TestFactory1(a)); }
    // pointer again
163
164
165
    static TestFactory1 *construct1_string(std::string a) {
        return new TestFactory1(std::move(a));
    }
166
167
168
169
170
171
172

    // Moveable type:
    // pointer:
    static TestFactory2 *construct2() { return new TestFactory2(); }
    // holder:
    static std::unique_ptr<TestFactory2> construct2(int a) { return std::unique_ptr<TestFactory2>(new TestFactory2(a)); }
    // by value moving:
173
    static TestFactory2 construct2(std::string a) { return TestFactory2(std::move(a)); }
174
175
176
177
178
179
180
181
182
183
184

    // shared_ptr holder type:
    // pointer:
    static TestFactory3 *construct3() { return new TestFactory3(); }
    // holder:
    static std::shared_ptr<TestFactory3> construct3(int a) { return std::shared_ptr<TestFactory3>(new TestFactory3(a)); }
};

TEST_SUBMODULE(factory_constructors, m) {

    // Define various trivial types to allow simpler overload resolution:
185
    py::module_ m_tag = m.def_submodule("tag");
186
187
188
189
190
191
192
193
194
195
196
197
#define MAKE_TAG_TYPE(Name) \
    struct Name##_tag {}; \
    py::class_<Name##_tag>(m_tag, #Name "_tag").def(py::init<>()); \
    m_tag.attr(#Name) = py::cast(Name##_tag{})
    MAKE_TAG_TYPE(pointer);
    MAKE_TAG_TYPE(unique_ptr);
    MAKE_TAG_TYPE(move);
    MAKE_TAG_TYPE(shared_ptr);
    MAKE_TAG_TYPE(derived);
    MAKE_TAG_TYPE(TF4);
    MAKE_TAG_TYPE(TF5);
    MAKE_TAG_TYPE(null_ptr);
198
199
    MAKE_TAG_TYPE(null_unique_ptr);
    MAKE_TAG_TYPE(null_shared_ptr);
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
    MAKE_TAG_TYPE(base);
    MAKE_TAG_TYPE(invalid_base);
    MAKE_TAG_TYPE(alias);
    MAKE_TAG_TYPE(unaliasable);
    MAKE_TAG_TYPE(mixed);

    // test_init_factory_basic, test_bad_type
    py::class_<TestFactory1>(m, "TestFactory1")
        .def(py::init([](unique_ptr_tag, int v) { return TestFactoryHelper::construct1(v); }))
        .def(py::init(&TestFactoryHelper::construct1_string)) // raw function pointer
        .def(py::init([](pointer_tag) { return TestFactoryHelper::construct1(); }))
        .def(py::init([](py::handle, int v, py::handle) { return TestFactoryHelper::construct1(v); }))
        .def_readwrite("value", &TestFactory1::value)
        ;
    py::class_<TestFactory2>(m, "TestFactory2")
        .def(py::init([](pointer_tag, int v) { return TestFactoryHelper::construct2(v); }))
216
217
218
        .def(py::init([](unique_ptr_tag, std::string v) {
            return TestFactoryHelper::construct2(std::move(v));
        }))
219
        .def(py::init([](move_tag) { return TestFactoryHelper::construct2(); }))
220
        .def_readwrite("value", &TestFactory2::value);
221
222
223

    // Stateful & reused:
    int c = 1;
Jason Rhinelander's avatar
Jason Rhinelander committed
224
    auto c4a = [c](pointer_tag, TF4_tag, int a) { (void) c; return new TestFactory4(a);};
225
226

    // test_init_factory_basic, test_init_factory_casting
227
228
    py::class_<TestFactory3, std::shared_ptr<TestFactory3>> pyTestFactory3(m, "TestFactory3");
    pyTestFactory3
229
        .def(py::init([](pointer_tag, int v) { return TestFactoryHelper::construct3(v); }))
230
231
        .def(py::init([](shared_ptr_tag) { return TestFactoryHelper::construct3(); }));
    ignoreOldStyleInitWarnings([&pyTestFactory3]() {
232
233
234
        pyTestFactory3.def("__init__", [](TestFactory3 &self, std::string v) {
            new (&self) TestFactory3(std::move(v));
        }); // placement-new ctor
235
236
    });
    pyTestFactory3
237
238
239
240
241
242
243
244
245
        // factories returning a derived type:
        .def(py::init(c4a)) // derived ptr
        .def(py::init([](pointer_tag, TF5_tag, int a) { return new TestFactory5(a); }))
        // derived shared ptr:
        .def(py::init([](shared_ptr_tag, TF4_tag, int a) { return std::make_shared<TestFactory4>(a); }))
        .def(py::init([](shared_ptr_tag, TF5_tag, int a) { return std::make_shared<TestFactory5>(a); }))

        // Returns nullptr:
        .def(py::init([](null_ptr_tag) { return (TestFactory3 *) nullptr; }))
246
247
        .def(py::init([](null_unique_ptr_tag) { return std::unique_ptr<TestFactory3>(); }))
        .def(py::init([](null_shared_ptr_tag) { return std::shared_ptr<TestFactory3>(); }))
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

        .def_readwrite("value", &TestFactory3::value)
        ;

    // test_init_factory_casting
    py::class_<TestFactory4, TestFactory3, std::shared_ptr<TestFactory4>>(m, "TestFactory4")
        .def(py::init(c4a)) // pointer
        ;

    // Doesn't need to be registered, but registering makes getting ConstructorStats easier:
    py::class_<TestFactory5, TestFactory3, std::shared_ptr<TestFactory5>>(m, "TestFactory5");

    // test_init_factory_alias
    // Alias testing
    py::class_<TestFactory6, PyTF6>(m, "TestFactory6")
        .def(py::init([](base_tag, int i) { return TestFactory6(i); }))
        .def(py::init([](alias_tag, int i) { return PyTF6(i); }))
265
        .def(py::init([](alias_tag, std::string s) { return PyTF6(std::move(s)); }))
266
267
        .def(py::init([](alias_tag, pointer_tag, int i) { return new PyTF6(i); }))
        .def(py::init([](base_tag, pointer_tag, int i) { return new TestFactory6(i); }))
268
269
        .def(py::init(
            [](base_tag, alias_tag, pointer_tag, int i) { return (TestFactory6 *) new PyTF6(i); }))
270
271
272
273

        .def("get", &TestFactory6::get)
        .def("has_alias", &TestFactory6::has_alias)

274
275
276
277
        .def_static(
            "get_cstats", &ConstructorStats::get<TestFactory6>, py::return_value_policy::reference)
        .def_static(
            "get_alias_cstats", &ConstructorStats::get<PyTF6>, py::return_value_policy::reference);
278
279
280
281

    // test_init_factory_dual
    // Separate alias constructor testing
    py::class_<TestFactory7, PyTF7, std::shared_ptr<TestFactory7>>(m, "TestFactory7")
282
283
284
285
286
287
288
289
290
291
292
        .def(py::init([](int i) { return TestFactory7(i); }, [](int i) { return PyTF7(i); }))
        .def(py::init([](pointer_tag, int i) { return new TestFactory7(i); },
                      [](pointer_tag, int i) { return new PyTF7(i); }))
        .def(py::init([](mixed_tag, int i) { return new TestFactory7(i); },
                      [](mixed_tag, int i) { return PyTF7(i); }))
        .def(py::init([](mixed_tag, const std::string &s) { return TestFactory7((int) s.size()); },
                      [](mixed_tag, const std::string &s) { return new PyTF7((int) s.size()); }))
        .def(py::init([](base_tag, pointer_tag, int i) { return new TestFactory7(i); },
                      [](base_tag, pointer_tag, int i) { return (TestFactory7 *) new PyTF7(i); }))
        .def(py::init([](alias_tag, pointer_tag, int i) { return new PyTF7(i); },
                      [](alias_tag, pointer_tag, int i) { return new PyTF7(10 * i); }))
293
294
        .def(py::init(
            [](shared_ptr_tag, base_tag, int i) { return std::make_shared<TestFactory7>(i); },
295
296
297
298
299
300
301
302
303
304
            [](shared_ptr_tag, base_tag, int i) {
                auto *p = new PyTF7(i);
                return std::shared_ptr<TestFactory7>(p);
            }))
        .def(py::init([](shared_ptr_tag,
                         invalid_base_tag,
                         int i) { return std::make_shared<TestFactory7>(i); },
                      [](shared_ptr_tag, invalid_base_tag, int i) {
                          return std::make_shared<TestFactory7>(i);
                      })) // <-- invalid alias factory
305
306
307
308

        .def("get", &TestFactory7::get)
        .def("has_alias", &TestFactory7::has_alias)

309
310
311
312
        .def_static(
            "get_cstats", &ConstructorStats::get<TestFactory7>, py::return_value_policy::reference)
        .def_static(
            "get_alias_cstats", &ConstructorStats::get<PyTF7>, py::return_value_policy::reference);
313
314
315
316
317

    // test_placement_new_alternative
    // Class with a custom new operator but *without* a placement new operator (issue #948)
    class NoPlacementNew {
    public:
318
        explicit NoPlacementNew(int i) : i(i) {}
319
320
321
322
323
324
325
326
327
328
329
        static void *operator new(std::size_t s) {
            auto *p = ::operator new(s);
            py::print("operator new called, returning", reinterpret_cast<uintptr_t>(p));
            return p;
        }
        static void operator delete(void *p) {
            py::print("operator delete called on", reinterpret_cast<uintptr_t>(p));
            ::operator delete(p);
        }
        int i;
    };
330
    // As of 2.2, `py::init<args>` no longer requires placement new
331
    py::class_<NoPlacementNew>(m, "NoPlacementNew")
332
        .def(py::init<int>())
333
334
335
336
337
338
339
340
        .def(py::init([]() { return new NoPlacementNew(100); }))
        .def_readwrite("i", &NoPlacementNew::i)
        ;


    // test_reallocations
    // Class that has verbose operator_new/operator_delete calls
    struct NoisyAlloc {
341
        NoisyAlloc(const NoisyAlloc &) = default;
342
343
        explicit NoisyAlloc(int i) { py::print(py::str("NoisyAlloc(int {})").format(i)); }
        explicit NoisyAlloc(double d) { py::print(py::str("NoisyAlloc(double {})").format(d)); }
344
345
346
347
348
349
350
351
352
353
354
        ~NoisyAlloc() { py::print("~NoisyAlloc()"); }

        static void *operator new(size_t s) { py::print("noisy new"); return ::operator new(s); }
        static void *operator new(size_t, void *p) { py::print("noisy placement new"); return p; }
        static void operator delete(void *p, size_t) { py::print("noisy delete"); ::operator delete(p); }
        static void operator delete(void *, void *) { py::print("noisy placement delete"); }
#if defined(_MSC_VER) && _MSC_VER < 1910
        // MSVC 2015 bug: the above "noisy delete" isn't invoked (fixed in MSVC 2017)
        static void operator delete(void *p) { py::print("noisy delete"); ::operator delete(p); }
#endif
    };
355
356
357


    py::class_<NoisyAlloc> pyNoisyAlloc(m, "NoisyAlloc");
358
359
360
        // Since these overloads have the same number of arguments, the dispatcher will try each of
        // them until the arguments convert.  Thus we can get a pre-allocation here when passing a
        // single non-integer:
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
    ignoreOldStyleInitWarnings([&pyNoisyAlloc]() {
        pyNoisyAlloc.def("__init__", [](NoisyAlloc *a, int i) { new (a) NoisyAlloc(i); }); // Regular constructor, runs first, requires preallocation
    });

    pyNoisyAlloc.def(py::init([](double d) { return new NoisyAlloc(d); }));

    // The two-argument version: first the factory pointer overload.
    pyNoisyAlloc.def(py::init([](int i, int) { return new NoisyAlloc(i); }));
    // Return-by-value:
    pyNoisyAlloc.def(py::init([](double d, int) { return NoisyAlloc(d); }));
    // Old-style placement new init; requires preallocation
    ignoreOldStyleInitWarnings([&pyNoisyAlloc]() {
        pyNoisyAlloc.def("__init__", [](NoisyAlloc &a, double d, double) { new (&a) NoisyAlloc(d); });
    });
    // Requires deallocation of previous overload preallocated value:
    pyNoisyAlloc.def(py::init([](int i, double) { return new NoisyAlloc(i); }));
    // Regular again: requires yet another preallocation
    ignoreOldStyleInitWarnings([&pyNoisyAlloc]() {
379
380
        pyNoisyAlloc.def(
            "__init__", [](NoisyAlloc &a, int i, const std::string &) { new (&a) NoisyAlloc(i); });
381
    });
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397

    // static_assert testing (the following def's should all fail with appropriate compilation errors):
#if 0
    struct BadF1Base {};
    struct BadF1 : BadF1Base {};
    struct PyBadF1 : BadF1 {};
    py::class_<BadF1, PyBadF1, std::shared_ptr<BadF1>> bf1(m, "BadF1");
    // wrapped factory function must return a compatible pointer, holder, or value
    bf1.def(py::init([]() { return 3; }));
    // incompatible factory function pointer return type
    bf1.def(py::init([]() { static int three = 3; return &three; }));
    // incompatible factory function std::shared_ptr<T> return type: cannot convert shared_ptr<T> to holder
    // (non-polymorphic base)
    bf1.def(py::init([]() { return std::shared_ptr<BadF1Base>(new BadF1()); }));
#endif
}