test_class.cpp 24.3 KB
Newer Older
1
/*
2
    tests/test_class.cpp -- test py::class_ definitions and basic functionality
3
4
5
6
7
8
9

    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>

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

10
11
12
13
#if defined(__INTEL_COMPILER) && __cplusplus >= 201703L
// Intel compiler requires a separate header file to support aligned new operators
// and does not set the __cpp_aligned_new feature macro.
// This header needs to be included before pybind11.
14
#    include <aligned_new>
15
16
#endif

17
18
#include <pybind11/stl.h>

19
#include "constructor_stats.h"
20
#include "local_bindings.h"
21
#include "pybind11_tests.h"
22

23
24
#include <utility>

25
PYBIND11_WARNING_DISABLE_MSVC(4324)
26
//     warning C4324: structure was padded due to alignment specifier
27

28
29
// test_brace_initialization
struct NoBraceInitialization {
30
    explicit NoBraceInitialization(std::vector<int> v) : vec{std::move(v)} {}
31
32
33
34
35
    template <typename T>
    NoBraceInitialization(std::initializer_list<T> l) : vec(l) {}

    std::vector<int> vec;
};
36

37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
namespace test_class {
namespace pr4220_tripped_over_this { // PR #4227

template <int>
struct SoEmpty {};

template <typename T>
std::string get_msg(const T &) {
    return "This is really only meant to exercise successful compilation.";
}

using Empty0 = SoEmpty<0x0>;

void bind_empty0(py::module_ &m) {
    py::class_<Empty0>(m, "Empty0").def(py::init<>()).def("get_msg", get_msg<Empty0>);
}

} // namespace pr4220_tripped_over_this
} // namespace test_class

57
TEST_SUBMODULE(class_, m) {
58
59
    m.def("obj_class_name", [](py::handle obj) { return py::detail::obj_class_name(obj.ptr()); });

60
61
    // test_instance
    struct NoConstructor {
62
63
64
        NoConstructor() = default;
        NoConstructor(const NoConstructor &) = default;
        NoConstructor(NoConstructor &&) = default;
65
66
67
68
69
70
71
        static NoConstructor *new_instance() {
            auto *ptr = new NoConstructor();
            print_created(ptr, "via new_instance");
            return ptr;
        }
        ~NoConstructor() { print_destroyed(this); }
    };
72
73
74
75
76
77
78
79
80
81
82
    struct NoConstructorNew {
        NoConstructorNew() = default;
        NoConstructorNew(const NoConstructorNew &) = default;
        NoConstructorNew(NoConstructorNew &&) = default;
        static NoConstructorNew *new_instance() {
            auto *ptr = new NoConstructorNew();
            print_created(ptr, "via new_instance");
            return ptr;
        }
        ~NoConstructorNew() { print_destroyed(this); }
    };
83
84
85

    py::class_<NoConstructor>(m, "NoConstructor")
        .def_static("new_instance", &NoConstructor::new_instance, "Return an instance");
86

87
    py::class_<NoConstructorNew>(m, "NoConstructorNew")
88
89
90
        .def(py::init([](const NoConstructorNew &self) { return self; })) // Need a NOOP __init__
        .def_static("__new__",
                    [](const py::object &) { return NoConstructorNew::new_instance(); });
91

92
93
94
95
96
97
98
    // test_inheritance
    class Pet {
    public:
        Pet(const std::string &name, const std::string &species)
            : m_name(name), m_species(species) {}
        std::string name() const { return m_name; }
        std::string species() const { return m_species; }
99

100
101
102
103
104
105
106
    private:
        std::string m_name;
        std::string m_species;
    };

    class Dog : public Pet {
    public:
107
        explicit Dog(const std::string &name) : Pet(name, "dog") {}
108
109
110
111
112
        std::string bark() const { return "Woof!"; }
    };

    class Rabbit : public Pet {
    public:
113
        explicit Rabbit(const std::string &name) : Pet(name, "parrot") {}
114
115
116
117
    };

    class Hamster : public Pet {
    public:
118
        explicit Hamster(const std::string &name) : Pet(name, "rodent") {}
119
120
121
122
123
124
125
    };

    class Chimera : public Pet {
        Chimera() : Pet("Kimmy", "chimera") {}
    };

    py::class_<Pet> pet_class(m, "Pet");
126
    pet_class.def(py::init<std::string, std::string>())
127
128
129
130
        .def("name", &Pet::name)
        .def("species", &Pet::species);

    /* One way of declaring a subclass relationship: reference parent's class_ object */
131
    py::class_<Dog>(m, "Dog", pet_class).def(py::init<std::string>());
132
133

    /* Another way of declaring a subclass relationship: reference parent's C++ type */
134
    py::class_<Rabbit, Pet>(m, "Rabbit").def(py::init<std::string>());
135
136

    /* And another: list parent in class template arguments */
137
    py::class_<Hamster, Pet>(m, "Hamster").def(py::init<std::string>());
138
139
140
141

    /* Constructors are not inherited by default */
    py::class_<Chimera, Pet>(m, "Chimera");

142
143
    m.def("pet_name_species",
          [](const Pet &pet) { return pet.name() + " is a " + pet.species(); });
144
145
146
    m.def("dog_bark", [](const Dog &dog) { return dog.bark(); });

    // test_automatic_upcasting
147
148
149
150
    struct BaseClass {
        BaseClass() = default;
        BaseClass(const BaseClass &) = default;
        BaseClass(BaseClass &&) = default;
151
        virtual ~BaseClass() = default;
152
    };
153
154
    struct DerivedClass1 : BaseClass {};
    struct DerivedClass2 : BaseClass {};
155
156
157
158
159

    py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
    py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
    py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());

160
161
    m.def("return_class_1", []() -> BaseClass * { return new DerivedClass1(); });
    m.def("return_class_2", []() -> BaseClass * { return new DerivedClass2(); });
162
163
164
165
166
167
168
    m.def("return_class_n", [](int n) -> BaseClass * {
        if (n == 1) {
            return new DerivedClass1();
        }
        if (n == 2) {
            return new DerivedClass2();
        }
169
170
        return new BaseClass();
    });
171
    m.def("return_none", []() -> BaseClass * { return nullptr; });
172
173

    // test_isinstance
174
    m.def("check_instances", [](const py::list &l) {
175
176
177
178
179
180
181
        return py::make_tuple(py::isinstance<py::tuple>(l[0]),
                              py::isinstance<py::dict>(l[1]),
                              py::isinstance<Pet>(l[2]),
                              py::isinstance<Pet>(l[3]),
                              py::isinstance<Dog>(l[4]),
                              py::isinstance<Rabbit>(l[5]),
                              py::isinstance<UnregisteredType>(l[6]));
182
183
    });

184
185
186
187
188
189
190
191
    struct Invalid {};

    // test_type
    m.def("check_type", [](int category) {
        // Currently not supported (via a fail at compile time)
        // See https://github.com/pybind/pybind11/issues/2486
        // if (category == 2)
        //     return py::type::of<int>();
192
        if (category == 1) {
193
            return py::type::of<DerivedClass1>();
194
        }
195
        return py::type::of<Invalid>();
196
197
    });

198
    m.def("get_type_of", [](py::object ob) { return py::type::of(std::move(ob)); });
199

200
    m.def("get_type_classic", [](py::handle h) { return h.get_type(); });
201

202
    m.def("as_type", [](const py::object &ob) { return py::type(ob); });
203

204
    // test_mismatched_holder
205
206
    struct MismatchBase1 {};
    struct MismatchDerived1 : MismatchBase1 {};
207

208
209
    struct MismatchBase2 {};
    struct MismatchDerived2 : MismatchBase2 {};
210
211

    m.def("mismatched_holder_1", []() {
212
        auto mod = py::module_::import("__main__");
213
214
215
216
        py::class_<MismatchBase1, std::shared_ptr<MismatchBase1>>(mod, "MismatchBase1");
        py::class_<MismatchDerived1, MismatchBase1>(mod, "MismatchDerived1");
    });
    m.def("mismatched_holder_2", []() {
217
        auto mod = py::module_::import("__main__");
218
        py::class_<MismatchBase2>(mod, "MismatchBase2");
219
220
        py::class_<MismatchDerived2, std::shared_ptr<MismatchDerived2>, MismatchBase2>(
            mod, "MismatchDerived2");
221
222
223
224
225
    });

    // test_override_static
    // #511: problem with inheritance + overwritten def_static
    struct MyBase {
226
        static std::unique_ptr<MyBase> make() { return std::unique_ptr<MyBase>(new MyBase()); }
227
228
229
230
231
232
233
234
    };

    struct MyDerived : MyBase {
        static std::unique_ptr<MyDerived> make() {
            return std::unique_ptr<MyDerived>(new MyDerived());
        }
    };

235
    py::class_<MyBase>(m, "MyBase").def_static("make", &MyBase::make);
236
237
238
239

    py::class_<MyDerived, MyBase>(m, "MyDerived")
        .def_static("make", &MyDerived::make)
        .def_static("make2", &MyDerived::make);
240
241
242
243
244

    // test_implicit_conversion_life_support
    struct ConvertibleFromUserType {
        int i;

245
        explicit ConvertibleFromUserType(UserType u) : i(u.value()) {}
246
247
    };

248
    py::class_<ConvertibleFromUserType>(m, "AcceptsUserType").def(py::init<UserType>());
249
250
251
    py::implicitly_convertible<UserType, ConvertibleFromUserType>();

    m.def("implicitly_convert_argument", [](const ConvertibleFromUserType &r) { return r.i; });
252
    m.def("implicitly_convert_variable", [](const py::object &o) {
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
        // `o` is `UserType` and `r` is a reference to a temporary created by implicit
        // conversion. This is valid when called inside a bound function because the temp
        // object is attached to the same life support system as the arguments.
        const auto &r = o.cast<const ConvertibleFromUserType &>();
        return r.i;
    });
    m.add_object("implicitly_convert_variable_fail", [&] {
        auto f = [](PyObject *, PyObject *args) -> PyObject * {
            auto o = py::reinterpret_borrow<py::tuple>(args)[0];
            try { // It should fail here because there is no life support.
                o.cast<const ConvertibleFromUserType &>();
            } catch (const py::cast_error &e) {
                return py::str(e.what()).release().ptr();
            }
            return py::str().release().ptr();
        };

270
        auto *def = new PyMethodDef{"f", f, METH_VARARGS, nullptr};
271
272
273
274
        py::capsule def_capsule(def,
                                [](void *ptr) { delete reinterpret_cast<PyMethodDef *>(ptr); });
        return py::reinterpret_steal<py::object>(
            PyCFunction_NewEx(def, def_capsule.ptr(), m.ptr()));
275
    }());
276
277
278
279

    // test_operator_new_delete
    struct HasOpNewDel {
        std::uint64_t i;
280
281
282
283
284
285
286
287
288
289
290
291
        static void *operator new(size_t s) {
            py::print("A new", s);
            return ::operator new(s);
        }
        static void *operator new(size_t s, void *ptr) {
            py::print("A placement-new", s);
            return ptr;
        }
        static void operator delete(void *p) {
            py::print("A delete");
            return ::operator delete(p);
        }
292
293
294
    };
    struct HasOpNewDelSize {
        std::uint32_t i;
295
296
297
298
299
300
301
302
303
304
305
306
        static void *operator new(size_t s) {
            py::print("B new", s);
            return ::operator new(s);
        }
        static void *operator new(size_t s, void *ptr) {
            py::print("B placement-new", s);
            return ptr;
        }
        static void operator delete(void *p, size_t s) {
            py::print("B delete", s);
            return ::operator delete(p);
        }
307
308
309
    };
    struct AliasedHasOpNewDelSize {
        std::uint64_t i;
310
311
312
313
314
315
316
317
318
319
320
321
        static void *operator new(size_t s) {
            py::print("C new", s);
            return ::operator new(s);
        }
        static void *operator new(size_t s, void *ptr) {
            py::print("C placement-new", s);
            return ptr;
        }
        static void operator delete(void *p, size_t s) {
            py::print("C delete", s);
            return ::operator delete(p);
        }
322
        virtual ~AliasedHasOpNewDelSize() = default;
Henry Schreiner's avatar
Henry Schreiner committed
323
        AliasedHasOpNewDelSize() = default;
324
        AliasedHasOpNewDelSize(const AliasedHasOpNewDelSize &) = delete;
325
326
327
    };
    struct PyAliasedHasOpNewDelSize : AliasedHasOpNewDelSize {
        PyAliasedHasOpNewDelSize() = default;
328
        explicit PyAliasedHasOpNewDelSize(int) {}
329
330
331
332
        std::uint64_t j;
    };
    struct HasOpNewDelBoth {
        std::uint32_t i[8];
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
        static void *operator new(size_t s) {
            py::print("D new", s);
            return ::operator new(s);
        }
        static void *operator new(size_t s, void *ptr) {
            py::print("D placement-new", s);
            return ptr;
        }
        static void operator delete(void *p) {
            py::print("D delete");
            return ::operator delete(p);
        }
        static void operator delete(void *p, size_t s) {
            py::print("D wrong delete", s);
            return ::operator delete(p);
        }
349
350
351
352
    };
    py::class_<HasOpNewDel>(m, "HasOpNewDel").def(py::init<>());
    py::class_<HasOpNewDelSize>(m, "HasOpNewDelSize").def(py::init<>());
    py::class_<HasOpNewDelBoth>(m, "HasOpNewDelBoth").def(py::init<>());
353
354
    py::class_<AliasedHasOpNewDelSize, PyAliasedHasOpNewDelSize> aliased(m,
                                                                         "AliasedHasOpNewDelSize");
355
356
357
    aliased.def(py::init<>());
    aliased.attr("size_noalias") = py::int_(sizeof(AliasedHasOpNewDelSize));
    aliased.attr("size_alias") = py::int_(sizeof(PyAliasedHasOpNewDelSize));
358
359
360
361

    // This test is actually part of test_local_bindings (test_duplicate_local), but we need a
    // definition in a different compilation unit within the same module:
    bind_local<LocalExternal, 17>(m, "LocalExternal", py::module_local());
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376

    // test_bind_protected_functions
    class ProtectedA {
    protected:
        int foo() const { return value; }

    private:
        int value = 42;
    };

    class PublicistA : public ProtectedA {
    public:
        using ProtectedA::foo;
    };

377
    py::class_<ProtectedA>(m, "ProtectedA").def(py::init<>()).def("foo", &PublicistA::foo);
378
379
380
381

    class ProtectedB {
    public:
        virtual ~ProtectedB() = default;
Henry Schreiner's avatar
Henry Schreiner committed
382
383
        ProtectedB() = default;
        ProtectedB(const ProtectedB &) = delete;
384
385
386

    protected:
        virtual int foo() const { return value; }
Lalaland's avatar
Lalaland committed
387
388
        virtual void *void_foo() { return static_cast<void *>(&value); }
        virtual void *get_self() { return static_cast<void *>(this); }
389
390
391
392
393
394
395

    private:
        int value = 42;
    };

    class TrampolineB : public ProtectedB {
    public:
396
        int foo() const override { PYBIND11_OVERRIDE(int, ProtectedB, foo, ); }
Lalaland's avatar
Lalaland committed
397
398
        void *void_foo() override { PYBIND11_OVERRIDE(void *, ProtectedB, void_foo, ); }
        void *get_self() override { PYBIND11_OVERRIDE(void *, ProtectedB, get_self, ); }
399
400
401
402
    };

    class PublicistB : public ProtectedB {
    public:
403
        // [workaround(intel)] = default does not work here
404
405
        // Removing or defaulting this destructor results in linking errors with the Intel compiler
        // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827)
406
        ~PublicistB() override{}; // NOLINT(modernize-use-equals-default)
407
        using ProtectedB::foo;
Lalaland's avatar
Lalaland committed
408
409
        using ProtectedB::get_self;
        using ProtectedB::void_foo;
410
411
    };

Lalaland's avatar
Lalaland committed
412
413
414
415
416
417
418
419
    m.def("read_foo", [](const void *original) {
        const int *ptr = reinterpret_cast<const int *>(original);
        return *ptr;
    });

    m.def("pointers_equal",
          [](const void *original, const void *comparison) { return original == comparison; });

420
421
    py::class_<ProtectedB, TrampolineB>(m, "ProtectedB")
        .def(py::init<>())
Lalaland's avatar
Lalaland committed
422
423
424
        .def("foo", &PublicistB::foo)
        .def("void_foo", &PublicistB::void_foo)
        .def("get_self", &PublicistB::get_self);
425
426
427
428
429
430
431
432
433
434
435

    // test_brace_initialization
    struct BraceInitialization {
        int field1;
        std::string field2;
    };

    py::class_<BraceInitialization>(m, "BraceInitialization")
        .def(py::init<int, const std::string &>())
        .def_readwrite("field1", &BraceInitialization::field1)
        .def_readwrite("field2", &BraceInitialization::field2);
436
437
438
439
440
441
    // We *don't* want to construct using braces when the given constructor argument maps to a
    // constructor, because brace initialization could go to the wrong place (in particular when
    // there is also an `initializer_list<T>`-accept constructor):
    py::class_<NoBraceInitialization>(m, "NoBraceInitialization")
        .def(py::init<std::vector<int>>())
        .def_readonly("vec", &NoBraceInitialization::vec);
442
443
444
445

    // test_reentrant_implicit_conversion_failure
    // #1035: issue with runaway reentrant implicit conversion
    struct BogusImplicitConversion {
446
        BogusImplicitConversion(const BogusImplicitConversion &) = default;
447
448
449
450
451
452
    };

    py::class_<BogusImplicitConversion>(m, "BogusImplicitConversion")
        .def(py::init<const BogusImplicitConversion &>());

    py::implicitly_convertible<int, BogusImplicitConversion>();
453
454
455
456
457
458
459
460
461
462
463

    // test_qualname
    // #1166: nested class docstring doesn't show nested name
    // Also related: tests that __qualname__ is set properly
    struct NestBase {};
    struct Nested {};
    py::class_<NestBase> base(m, "NestBase");
    base.def(py::init<>());
    py::class_<Nested>(base, "Nested")
        .def(py::init<>())
        .def("fn", [](Nested &, int, NestBase &, Nested &) {})
464
465
        .def(
            "fa", [](Nested &, int, NestBase &, Nested &) {}, "a"_a, "b"_a, "c"_a);
466
467
    base.def("g", [](NestBase &, Nested &) {});
    base.def("h", []() { return NestBase(); });
468
469
470
471
472
473
474

    // test_error_after_conversion
    // The second-pass path through dispatcher() previously didn't
    // remember which overload was used, and would crash trying to
    // generate a useful error message

    struct NotRegistered {};
475
476
477
    struct StringWrapper {
        std::string str;
    };
478
479
    m.def("test_error_after_conversions", [](int) {});
    m.def("test_error_after_conversions",
480
          [](const StringWrapper &) -> NotRegistered { return {}; });
481
482
    py::class_<StringWrapper>(m, "StringWrapper").def(py::init<std::string>());
    py::implicitly_convertible<std::string, StringWrapper>();
483

484
485
486
487
488
489
#if defined(PYBIND11_CPP17)
    struct alignas(1024) Aligned {
        std::uintptr_t ptr() const { return (uintptr_t) this; }
    };
    py::class_<Aligned>(m, "Aligned").def(py::init<>()).def("ptr", &Aligned::ptr);
#endif
490
491
492
493
494
495
496
497

    // test_final
    struct IsFinal final {};
    py::class_<IsFinal>(m, "IsFinal", py::is_final());

    // test_non_final_final
    struct IsNonFinalFinal {};
    py::class_<IsNonFinalFinal>(m, "IsNonFinalFinal", py::is_final());
498

499
    // test_exception_rvalue_abort
500
    struct PyPrintDestructor {
501
        PyPrintDestructor() = default;
502
        ~PyPrintDestructor() { py::print("Print from destructor"); }
503
504
505
506
507
        void throw_something() { throw std::runtime_error("error"); }
    };
    py::class_<PyPrintDestructor>(m, "PyPrintDestructor")
        .def(py::init<>())
        .def("throw_something", &PyPrintDestructor::throw_something);
508

509
    // test_multiple_instances_with_same_pointer
510
511
512
    struct SamePointer {};
    static SamePointer samePointer;
    py::class_<SamePointer, std::unique_ptr<SamePointer, py::nodelete>>(m, "SamePointer")
513
        .def(py::init([]() { return &samePointer; }));
514
515

    struct Empty {};
516
    py::class_<Empty>(m, "Empty").def(py::init<>());
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538

    // test_base_and_derived_nested_scope
    struct BaseWithNested {
        struct Nested {};
    };

    struct DerivedWithNested : BaseWithNested {
        struct Nested {};
    };

    py::class_<BaseWithNested> baseWithNested_class(m, "BaseWithNested");
    py::class_<DerivedWithNested, BaseWithNested> derivedWithNested_class(m, "DerivedWithNested");
    py::class_<BaseWithNested::Nested>(baseWithNested_class, "Nested")
        .def_static("get_name", []() { return "BaseWithNested::Nested"; });
    py::class_<DerivedWithNested::Nested>(derivedWithNested_class, "Nested")
        .def_static("get_name", []() { return "DerivedWithNested::Nested"; });

    // test_register_duplicate_class
    struct Duplicate {};
    struct OtherDuplicate {};
    struct DuplicateNested {};
    struct OtherDuplicateNested {};
539
540

    m.def("register_duplicate_class_name", [](const py::module_ &m) {
541
542
543
        py::class_<Duplicate>(m, "Duplicate");
        py::class_<OtherDuplicate>(m, "Duplicate");
    });
544
    m.def("register_duplicate_class_type", [](const py::module_ &m) {
545
546
547
        py::class_<OtherDuplicate>(m, "OtherDuplicate");
        py::class_<OtherDuplicate>(m, "YetAnotherDuplicate");
    });
548
    m.def("register_duplicate_nested_class_name", [](const py::object &gt) {
549
550
551
        py::class_<DuplicateNested>(gt, "DuplicateNested");
        py::class_<OtherDuplicateNested>(gt, "DuplicateNested");
    });
552
    m.def("register_duplicate_nested_class_type", [](const py::object &gt) {
553
554
555
        py::class_<OtherDuplicateNested>(gt, "OtherDuplicateNested");
        py::class_<OtherDuplicateNested>(gt, "YetAnotherDuplicateNested");
    });
556
557

    test_class::pr4220_tripped_over_this::bind_empty0(m);
558
}
559

560
561
562
template <int N>
class BreaksBase {
public:
Henry Schreiner's avatar
Henry Schreiner committed
563
564
    virtual ~BreaksBase() = default;
    BreaksBase() = default;
565
    BreaksBase(const BreaksBase &) = delete;
Henry Schreiner's avatar
Henry Schreiner committed
566
};
567
568
template <int N>
class BreaksTramp : public BreaksBase<N> {};
569
// These should all compile just fine:
570
571
572
573
574
575
576
577
using DoesntBreak1 = py::class_<BreaksBase<1>, std::unique_ptr<BreaksBase<1>>, BreaksTramp<1>>;
using DoesntBreak2 = py::class_<BreaksBase<2>, BreaksTramp<2>, std::unique_ptr<BreaksBase<2>>>;
using DoesntBreak3 = py::class_<BreaksBase<3>, std::unique_ptr<BreaksBase<3>>>;
using DoesntBreak4 = py::class_<BreaksBase<4>, BreaksTramp<4>>;
using DoesntBreak5 = py::class_<BreaksBase<5>>;
using DoesntBreak6 = py::class_<BreaksBase<6>, std::shared_ptr<BreaksBase<6>>, BreaksTramp<6>>;
using DoesntBreak7 = py::class_<BreaksBase<7>, BreaksTramp<7>, std::shared_ptr<BreaksBase<7>>>;
using DoesntBreak8 = py::class_<BreaksBase<8>, std::shared_ptr<BreaksBase<8>>>;
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
#define CHECK_BASE(N)                                                                             \
    static_assert(std::is_same<typename DoesntBreak##N::type, BreaksBase<(N)>>::value,            \
                  "DoesntBreak" #N " has wrong type!")
CHECK_BASE(1);
CHECK_BASE(2);
CHECK_BASE(3);
CHECK_BASE(4);
CHECK_BASE(5);
CHECK_BASE(6);
CHECK_BASE(7);
CHECK_BASE(8);
#define CHECK_ALIAS(N)                                                                            \
    static_assert(                                                                                \
        DoesntBreak##N::has_alias                                                                 \
            && std::is_same<typename DoesntBreak##N::type_alias, BreaksTramp<(N)>>::value,        \
593
        "DoesntBreak" #N " has wrong type_alias!")
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
#define CHECK_NOALIAS(N)                                                                          \
    static_assert(!DoesntBreak##N::has_alias                                                      \
                      && std::is_void<typename DoesntBreak##N::type_alias>::value,                \
                  "DoesntBreak" #N " has type alias, but shouldn't!")
CHECK_ALIAS(1);
CHECK_ALIAS(2);
CHECK_NOALIAS(3);
CHECK_ALIAS(4);
CHECK_NOALIAS(5);
CHECK_ALIAS(6);
CHECK_ALIAS(7);
CHECK_NOALIAS(8);
#define CHECK_HOLDER(N, TYPE)                                                                     \
    static_assert(std::is_same<typename DoesntBreak##N::holder_type,                              \
                               std::TYPE##_ptr<BreaksBase<(N)>>>::value,                          \
                  "DoesntBreak" #N " has wrong holder_type!")
CHECK_HOLDER(1, unique);
CHECK_HOLDER(2, unique);
CHECK_HOLDER(3, unique);
CHECK_HOLDER(4, unique);
CHECK_HOLDER(5, unique);
CHECK_HOLDER(6, shared);
CHECK_HOLDER(7, shared);
CHECK_HOLDER(8, shared);
618
619
620
621
622
623

// There's no nice way to test that these fail because they fail to compile; leave them here,
// though, so that they can be manually tested by uncommenting them (and seeing that compilation
// failures occurs).

// We have to actually look into the type: the typedef alone isn't enough to instantiate the type:
624
625
626
#define CHECK_BROKEN(N)                                                                           \
    static_assert(std::is_same<typename Breaks##N::type, BreaksBase<-(N)>>::value,                \
                  "Breaks1 has wrong type!");
627

628
629
#ifdef PYBIND11_NEVER_DEFINED_EVER
// Two holder classes:
630
631
632
typedef py::
    class_<BreaksBase<-1>, std::unique_ptr<BreaksBase<-1>>, std::unique_ptr<BreaksBase<-1>>>
        Breaks1;
633
634
635
636
637
CHECK_BROKEN(1);
// Two aliases:
typedef py::class_<BreaksBase<-2>, BreaksTramp<-2>, BreaksTramp<-2>> Breaks2;
CHECK_BROKEN(2);
// Holder + 2 aliases
638
639
640
typedef py::
    class_<BreaksBase<-3>, std::unique_ptr<BreaksBase<-3>>, BreaksTramp<-3>, BreaksTramp<-3>>
        Breaks3;
641
642
CHECK_BROKEN(3);
// Alias + 2 holders
643
644
645
646
647
typedef py::class_<BreaksBase<-4>,
                   std::unique_ptr<BreaksBase<-4>>,
                   BreaksTramp<-4>,
                   std::shared_ptr<BreaksBase<-4>>>
    Breaks4;
648
649
650
651
652
CHECK_BROKEN(4);
// Invalid option (not a subclass or holder)
typedef py::class_<BreaksBase<-5>, BreaksTramp<-4>> Breaks5;
CHECK_BROKEN(5);
// Invalid option: multiple inheritance not supported:
653
654
template <>
struct BreaksBase<-8> : BreaksBase<-6>, BreaksBase<-7> {};
655
656
657
typedef py::class_<BreaksBase<-8>, BreaksBase<-6>, BreaksBase<-7>> Breaks8;
CHECK_BROKEN(8);
#endif