test_class.cpp revision 12391:ceeca8b41e4b
110152Satgutier@umich.edu/* 210152Satgutier@umich.edu tests/test_class.cpp -- test py::class_ definitions and basic functionality 310152Satgutier@umich.edu 410152Satgutier@umich.edu Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> 510152Satgutier@umich.edu 610152Satgutier@umich.edu All rights reserved. Use of this source code is governed by a 710152Satgutier@umich.edu BSD-style license that can be found in the LICENSE file. 810152Satgutier@umich.edu*/ 910152Satgutier@umich.edu 1010152Satgutier@umich.edu#include "pybind11_tests.h" 1110152Satgutier@umich.edu#include "constructor_stats.h" 1210152Satgutier@umich.edu#include "local_bindings.h" 1310152Satgutier@umich.edu 1410152Satgutier@umich.eduTEST_SUBMODULE(class_, m) { 1510152Satgutier@umich.edu // test_instance 1610152Satgutier@umich.edu struct NoConstructor { 1710152Satgutier@umich.edu static NoConstructor *new_instance() { 1810152Satgutier@umich.edu auto *ptr = new NoConstructor(); 1910152Satgutier@umich.edu print_created(ptr, "via new_instance"); 2010152Satgutier@umich.edu return ptr; 2110152Satgutier@umich.edu } 2210152Satgutier@umich.edu ~NoConstructor() { print_destroyed(this); } 2310152Satgutier@umich.edu }; 2410152Satgutier@umich.edu 2510152Satgutier@umich.edu py::class_<NoConstructor>(m, "NoConstructor") 2610152Satgutier@umich.edu .def_static("new_instance", &NoConstructor::new_instance, "Return an instance"); 2710152Satgutier@umich.edu 2810152Satgutier@umich.edu // test_inheritance 2910152Satgutier@umich.edu class Pet { 3010152Satgutier@umich.edu public: 3110152Satgutier@umich.edu Pet(const std::string &name, const std::string &species) 3210152Satgutier@umich.edu : m_name(name), m_species(species) {} 3310152Satgutier@umich.edu std::string name() const { return m_name; } 3410152Satgutier@umich.edu std::string species() const { return m_species; } 3510152Satgutier@umich.edu private: 3610152Satgutier@umich.edu std::string m_name; 3710152Satgutier@umich.edu std::string m_species; 3810152Satgutier@umich.edu }; 3910152Satgutier@umich.edu 4010152Satgutier@umich.edu class Dog : public Pet { 4110152Satgutier@umich.edu public: 4210152Satgutier@umich.edu Dog(const std::string &name) : Pet(name, "dog") {} 4310152Satgutier@umich.edu std::string bark() const { return "Woof!"; } 4410152Satgutier@umich.edu }; 4510152Satgutier@umich.edu 4610152Satgutier@umich.edu class Rabbit : public Pet { 4710152Satgutier@umich.edu public: 4810152Satgutier@umich.edu Rabbit(const std::string &name) : Pet(name, "parrot") {} 4910152Satgutier@umich.edu }; 5010152Satgutier@umich.edu 5110152Satgutier@umich.edu class Hamster : public Pet { 5210152Satgutier@umich.edu public: 5310152Satgutier@umich.edu Hamster(const std::string &name) : Pet(name, "rodent") {} 5410152Satgutier@umich.edu }; 5510152Satgutier@umich.edu 5610152Satgutier@umich.edu class Chimera : public Pet { 5710152Satgutier@umich.edu Chimera() : Pet("Kimmy", "chimera") {} 5810152Satgutier@umich.edu }; 5910152Satgutier@umich.edu 6010152Satgutier@umich.edu py::class_<Pet> pet_class(m, "Pet"); 6110152Satgutier@umich.edu pet_class 6210152Satgutier@umich.edu .def(py::init<std::string, std::string>()) 6310152Satgutier@umich.edu .def("name", &Pet::name) 6410152Satgutier@umich.edu .def("species", &Pet::species); 6510152Satgutier@umich.edu 6610152Satgutier@umich.edu /* One way of declaring a subclass relationship: reference parent's class_ object */ 6710152Satgutier@umich.edu py::class_<Dog>(m, "Dog", pet_class) 6810152Satgutier@umich.edu .def(py::init<std::string>()); 6910152Satgutier@umich.edu 7010152Satgutier@umich.edu /* Another way of declaring a subclass relationship: reference parent's C++ type */ 7110152Satgutier@umich.edu py::class_<Rabbit, Pet>(m, "Rabbit") 7210152Satgutier@umich.edu .def(py::init<std::string>()); 7310152Satgutier@umich.edu 7410152Satgutier@umich.edu /* And another: list parent in class template arguments */ 7510152Satgutier@umich.edu py::class_<Hamster, Pet>(m, "Hamster") 7610152Satgutier@umich.edu .def(py::init<std::string>()); 7710152Satgutier@umich.edu 7810152Satgutier@umich.edu /* Constructors are not inherited by default */ 7910152Satgutier@umich.edu py::class_<Chimera, Pet>(m, "Chimera"); 8010152Satgutier@umich.edu 8110152Satgutier@umich.edu m.def("pet_name_species", [](const Pet &pet) { return pet.name() + " is a " + pet.species(); }); 8210152Satgutier@umich.edu m.def("dog_bark", [](const Dog &dog) { return dog.bark(); }); 8310152Satgutier@umich.edu 8410152Satgutier@umich.edu // test_automatic_upcasting 8510152Satgutier@umich.edu struct BaseClass { virtual ~BaseClass() {} }; 8610152Satgutier@umich.edu struct DerivedClass1 : BaseClass { }; 8710152Satgutier@umich.edu struct DerivedClass2 : BaseClass { }; 8810152Satgutier@umich.edu 8910152Satgutier@umich.edu py::class_<BaseClass>(m, "BaseClass").def(py::init<>()); 9010152Satgutier@umich.edu py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>()); 9110152Satgutier@umich.edu py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>()); 9210152Satgutier@umich.edu 9310152Satgutier@umich.edu m.def("return_class_1", []() -> BaseClass* { return new DerivedClass1(); }); 9410152Satgutier@umich.edu m.def("return_class_2", []() -> BaseClass* { return new DerivedClass2(); }); 9510152Satgutier@umich.edu m.def("return_class_n", [](int n) -> BaseClass* { 9610152Satgutier@umich.edu if (n == 1) return new DerivedClass1(); 9710152Satgutier@umich.edu if (n == 2) return new DerivedClass2(); 9810152Satgutier@umich.edu return new BaseClass(); 9910152Satgutier@umich.edu }); 10010152Satgutier@umich.edu m.def("return_none", []() -> BaseClass* { return nullptr; }); 10110152Satgutier@umich.edu 10210152Satgutier@umich.edu // test_isinstance 10310152Satgutier@umich.edu m.def("check_instances", [](py::list l) { 10410152Satgutier@umich.edu return py::make_tuple( 10510152Satgutier@umich.edu py::isinstance<py::tuple>(l[0]), 10610152Satgutier@umich.edu py::isinstance<py::dict>(l[1]), 10710152Satgutier@umich.edu py::isinstance<Pet>(l[2]), 10810152Satgutier@umich.edu py::isinstance<Pet>(l[3]), 10910152Satgutier@umich.edu py::isinstance<Dog>(l[4]), 11010152Satgutier@umich.edu py::isinstance<Rabbit>(l[5]), 11110152Satgutier@umich.edu py::isinstance<UnregisteredType>(l[6]) 11210152Satgutier@umich.edu ); 11310152Satgutier@umich.edu }); 11410152Satgutier@umich.edu 11510152Satgutier@umich.edu // test_mismatched_holder 11610152Satgutier@umich.edu struct MismatchBase1 { }; 11710152Satgutier@umich.edu struct MismatchDerived1 : MismatchBase1 { }; 11810152Satgutier@umich.edu 11910152Satgutier@umich.edu struct MismatchBase2 { }; 12010152Satgutier@umich.edu struct MismatchDerived2 : MismatchBase2 { }; 12110152Satgutier@umich.edu 12210152Satgutier@umich.edu m.def("mismatched_holder_1", []() { 12310152Satgutier@umich.edu auto mod = py::module::import("__main__"); 12410152Satgutier@umich.edu py::class_<MismatchBase1, std::shared_ptr<MismatchBase1>>(mod, "MismatchBase1"); 12510152Satgutier@umich.edu py::class_<MismatchDerived1, MismatchBase1>(mod, "MismatchDerived1"); 12610152Satgutier@umich.edu }); 12710152Satgutier@umich.edu m.def("mismatched_holder_2", []() { 12810152Satgutier@umich.edu auto mod = py::module::import("__main__"); 12910152Satgutier@umich.edu py::class_<MismatchBase2>(mod, "MismatchBase2"); 13010152Satgutier@umich.edu py::class_<MismatchDerived2, std::shared_ptr<MismatchDerived2>, 13110152Satgutier@umich.edu MismatchBase2>(mod, "MismatchDerived2"); 13210152Satgutier@umich.edu }); 13310152Satgutier@umich.edu 13410152Satgutier@umich.edu // test_override_static 13510152Satgutier@umich.edu // #511: problem with inheritance + overwritten def_static 13610152Satgutier@umich.edu struct MyBase { 13710152Satgutier@umich.edu static std::unique_ptr<MyBase> make() { 13810152Satgutier@umich.edu return std::unique_ptr<MyBase>(new MyBase()); 13910152Satgutier@umich.edu } 14010152Satgutier@umich.edu }; 14110152Satgutier@umich.edu 14210152Satgutier@umich.edu struct MyDerived : MyBase { 14310152Satgutier@umich.edu static std::unique_ptr<MyDerived> make() { 14410152Satgutier@umich.edu return std::unique_ptr<MyDerived>(new MyDerived()); 14510152Satgutier@umich.edu } 14610152Satgutier@umich.edu }; 14710152Satgutier@umich.edu 14810152Satgutier@umich.edu py::class_<MyBase>(m, "MyBase") 14910152Satgutier@umich.edu .def_static("make", &MyBase::make); 15010152Satgutier@umich.edu 15110152Satgutier@umich.edu py::class_<MyDerived, MyBase>(m, "MyDerived") 15210152Satgutier@umich.edu .def_static("make", &MyDerived::make) 15310152Satgutier@umich.edu .def_static("make2", &MyDerived::make); 15410152Satgutier@umich.edu 15510152Satgutier@umich.edu // test_implicit_conversion_life_support 15610152Satgutier@umich.edu struct ConvertibleFromUserType { 15710152Satgutier@umich.edu int i; 15810152Satgutier@umich.edu 15910152Satgutier@umich.edu ConvertibleFromUserType(UserType u) : i(u.value()) { } 16010152Satgutier@umich.edu }; 16110152Satgutier@umich.edu 16210152Satgutier@umich.edu py::class_<ConvertibleFromUserType>(m, "AcceptsUserType") 16310152Satgutier@umich.edu .def(py::init<UserType>()); 16410152Satgutier@umich.edu py::implicitly_convertible<UserType, ConvertibleFromUserType>(); 16510152Satgutier@umich.edu 16610152Satgutier@umich.edu m.def("implicitly_convert_argument", [](const ConvertibleFromUserType &r) { return r.i; }); 16710152Satgutier@umich.edu m.def("implicitly_convert_variable", [](py::object o) { 16810152Satgutier@umich.edu // `o` is `UserType` and `r` is a reference to a temporary created by implicit 16910152Satgutier@umich.edu // conversion. This is valid when called inside a bound function because the temp 17010152Satgutier@umich.edu // object is attached to the same life support system as the arguments. 17110152Satgutier@umich.edu const auto &r = o.cast<const ConvertibleFromUserType &>(); 17210152Satgutier@umich.edu return r.i; 17310152Satgutier@umich.edu }); 17410152Satgutier@umich.edu m.add_object("implicitly_convert_variable_fail", [&] { 17510152Satgutier@umich.edu auto f = [](PyObject *, PyObject *args) -> PyObject * { 17610152Satgutier@umich.edu auto o = py::reinterpret_borrow<py::tuple>(args)[0]; 17710152Satgutier@umich.edu try { // It should fail here because there is no life support. 17810152Satgutier@umich.edu o.cast<const ConvertibleFromUserType &>(); 17910152Satgutier@umich.edu } catch (const py::cast_error &e) { 18010152Satgutier@umich.edu return py::str(e.what()).release().ptr(); 18110152Satgutier@umich.edu } 18210152Satgutier@umich.edu return py::str().release().ptr(); 18310152Satgutier@umich.edu }; 18410152Satgutier@umich.edu 18510152Satgutier@umich.edu auto def = new PyMethodDef{"f", f, METH_VARARGS, nullptr}; 18610152Satgutier@umich.edu return py::reinterpret_steal<py::object>(PyCFunction_NewEx(def, nullptr, m.ptr())); 18710152Satgutier@umich.edu }()); 18810152Satgutier@umich.edu 18910152Satgutier@umich.edu // test_operator_new_delete 19010152Satgutier@umich.edu struct HasOpNewDel { 19110152Satgutier@umich.edu std::uint64_t i; 19210152Satgutier@umich.edu static void *operator new(size_t s) { py::print("A new", s); return ::operator new(s); } 19310152Satgutier@umich.edu static void *operator new(size_t s, void *ptr) { py::print("A placement-new", s); return ptr; } 19410152Satgutier@umich.edu static void operator delete(void *p) { py::print("A delete"); return ::operator delete(p); } 19510152Satgutier@umich.edu }; 19610152Satgutier@umich.edu struct HasOpNewDelSize { 19710152Satgutier@umich.edu std::uint32_t i; 19810152Satgutier@umich.edu static void *operator new(size_t s) { py::print("B new", s); return ::operator new(s); } 19910152Satgutier@umich.edu static void *operator new(size_t s, void *ptr) { py::print("B placement-new", s); return ptr; } 20010152Satgutier@umich.edu static void operator delete(void *p, size_t s) { py::print("B delete", s); return ::operator delete(p); } 20110152Satgutier@umich.edu }; 20210152Satgutier@umich.edu struct AliasedHasOpNewDelSize { 20310152Satgutier@umich.edu std::uint64_t i; 20410152Satgutier@umich.edu static void *operator new(size_t s) { py::print("C new", s); return ::operator new(s); } 20510152Satgutier@umich.edu static void *operator new(size_t s, void *ptr) { py::print("C placement-new", s); return ptr; } 20610152Satgutier@umich.edu static void operator delete(void *p, size_t s) { py::print("C delete", s); return ::operator delete(p); } 20710152Satgutier@umich.edu virtual ~AliasedHasOpNewDelSize() = default; 20810152Satgutier@umich.edu }; 20910152Satgutier@umich.edu struct PyAliasedHasOpNewDelSize : AliasedHasOpNewDelSize { 21010152Satgutier@umich.edu PyAliasedHasOpNewDelSize() = default; 21110152Satgutier@umich.edu PyAliasedHasOpNewDelSize(int) { } 21210152Satgutier@umich.edu std::uint64_t j; 21310152Satgutier@umich.edu }; 21410152Satgutier@umich.edu struct HasOpNewDelBoth { 21510152Satgutier@umich.edu std::uint32_t i[8]; 21610152Satgutier@umich.edu static void *operator new(size_t s) { py::print("D new", s); return ::operator new(s); } 21710152Satgutier@umich.edu static void *operator new(size_t s, void *ptr) { py::print("D placement-new", s); return ptr; } 21810152Satgutier@umich.edu static void operator delete(void *p) { py::print("D delete"); return ::operator delete(p); } 21910152Satgutier@umich.edu static void operator delete(void *p, size_t s) { py::print("D wrong delete", s); return ::operator delete(p); } 22010152Satgutier@umich.edu }; 22110152Satgutier@umich.edu py::class_<HasOpNewDel>(m, "HasOpNewDel").def(py::init<>()); 22210152Satgutier@umich.edu py::class_<HasOpNewDelSize>(m, "HasOpNewDelSize").def(py::init<>()); 22310152Satgutier@umich.edu py::class_<HasOpNewDelBoth>(m, "HasOpNewDelBoth").def(py::init<>()); 22410152Satgutier@umich.edu py::class_<AliasedHasOpNewDelSize, PyAliasedHasOpNewDelSize> aliased(m, "AliasedHasOpNewDelSize"); 22510152Satgutier@umich.edu aliased.def(py::init<>()); 22610152Satgutier@umich.edu aliased.attr("size_noalias") = py::int_(sizeof(AliasedHasOpNewDelSize)); 22710152Satgutier@umich.edu aliased.attr("size_alias") = py::int_(sizeof(PyAliasedHasOpNewDelSize)); 22810152Satgutier@umich.edu 22910152Satgutier@umich.edu // This test is actually part of test_local_bindings (test_duplicate_local), but we need a 23010152Satgutier@umich.edu // definition in a different compilation unit within the same module: 23110152Satgutier@umich.edu bind_local<LocalExternal, 17>(m, "LocalExternal", py::module_local()); 23210152Satgutier@umich.edu 23310152Satgutier@umich.edu // test_bind_protected_functions 23410152Satgutier@umich.edu class ProtectedA { 23510152Satgutier@umich.edu protected: 23610152Satgutier@umich.edu int foo() const { return value; } 23710152Satgutier@umich.edu 23810152Satgutier@umich.edu private: 23910152Satgutier@umich.edu int value = 42; 24010152Satgutier@umich.edu }; 24110152Satgutier@umich.edu 24210152Satgutier@umich.edu class PublicistA : public ProtectedA { 24310152Satgutier@umich.edu public: 24410152Satgutier@umich.edu using ProtectedA::foo; 24510152Satgutier@umich.edu }; 24610152Satgutier@umich.edu 24710152Satgutier@umich.edu py::class_<ProtectedA>(m, "ProtectedA") 24810152Satgutier@umich.edu .def(py::init<>()) 24910152Satgutier@umich.edu#if !defined(_MSC_VER) || _MSC_VER >= 1910 25010152Satgutier@umich.edu .def("foo", &PublicistA::foo); 25110152Satgutier@umich.edu#else 25210152Satgutier@umich.edu .def("foo", static_cast<int (ProtectedA::*)() const>(&PublicistA::foo)); 25310152Satgutier@umich.edu#endif 25410152Satgutier@umich.edu 25510152Satgutier@umich.edu class ProtectedB { 25610152Satgutier@umich.edu public: 25710152Satgutier@umich.edu virtual ~ProtectedB() = default; 25810152Satgutier@umich.edu 25910152Satgutier@umich.edu protected: 26010152Satgutier@umich.edu virtual int foo() const { return value; } 26110152Satgutier@umich.edu 26210152Satgutier@umich.edu private: 26310152Satgutier@umich.edu int value = 42; 26410152Satgutier@umich.edu }; 26510152Satgutier@umich.edu 26610152Satgutier@umich.edu class TrampolineB : public ProtectedB { 26710152Satgutier@umich.edu public: 26810152Satgutier@umich.edu int foo() const override { PYBIND11_OVERLOAD(int, ProtectedB, foo, ); } 26910152Satgutier@umich.edu }; 27010152Satgutier@umich.edu 27110152Satgutier@umich.edu class PublicistB : public ProtectedB { 27210152Satgutier@umich.edu public: 27310152Satgutier@umich.edu using ProtectedB::foo; 27410152Satgutier@umich.edu }; 27510152Satgutier@umich.edu 27610152Satgutier@umich.edu py::class_<ProtectedB, TrampolineB>(m, "ProtectedB") 27710152Satgutier@umich.edu .def(py::init<>()) 27810152Satgutier@umich.edu#if !defined(_MSC_VER) || _MSC_VER >= 1910 27910152Satgutier@umich.edu .def("foo", &PublicistB::foo); 28010152Satgutier@umich.edu#else 28110152Satgutier@umich.edu .def("foo", static_cast<int (ProtectedB::*)() const>(&PublicistB::foo)); 28210152Satgutier@umich.edu#endif 28310152Satgutier@umich.edu 28410152Satgutier@umich.edu // test_brace_initialization 28510152Satgutier@umich.edu struct BraceInitialization { 28610152Satgutier@umich.edu int field1; 28710152Satgutier@umich.edu std::string field2; 28810152Satgutier@umich.edu }; 28910152Satgutier@umich.edu 29010152Satgutier@umich.edu py::class_<BraceInitialization>(m, "BraceInitialization") 29110152Satgutier@umich.edu .def(py::init<int, const std::string &>()) 29210152Satgutier@umich.edu .def_readwrite("field1", &BraceInitialization::field1) 29310152Satgutier@umich.edu .def_readwrite("field2", &BraceInitialization::field2); 29410152Satgutier@umich.edu 29510152Satgutier@umich.edu // test_reentrant_implicit_conversion_failure 29610152Satgutier@umich.edu // #1035: issue with runaway reentrant implicit conversion 29710152Satgutier@umich.edu struct BogusImplicitConversion { 29810152Satgutier@umich.edu BogusImplicitConversion(const BogusImplicitConversion &) { } 29910152Satgutier@umich.edu }; 30010152Satgutier@umich.edu 30110152Satgutier@umich.edu py::class_<BogusImplicitConversion>(m, "BogusImplicitConversion") 30210152Satgutier@umich.edu .def(py::init<const BogusImplicitConversion &>()); 30310152Satgutier@umich.edu 30410152Satgutier@umich.edu py::implicitly_convertible<int, BogusImplicitConversion>(); 30510152Satgutier@umich.edu} 30610152Satgutier@umich.edu 30710152Satgutier@umich.edutemplate <int N> class BreaksBase { public: virtual ~BreaksBase() = default; }; 30810152Satgutier@umich.edutemplate <int N> class BreaksTramp : public BreaksBase<N> {}; 30910152Satgutier@umich.edu// These should all compile just fine: 31010152Satgutier@umich.edutypedef py::class_<BreaksBase<1>, std::unique_ptr<BreaksBase<1>>, BreaksTramp<1>> DoesntBreak1; 31110152Satgutier@umich.edutypedef py::class_<BreaksBase<2>, BreaksTramp<2>, std::unique_ptr<BreaksBase<2>>> DoesntBreak2; 31210152Satgutier@umich.edutypedef py::class_<BreaksBase<3>, std::unique_ptr<BreaksBase<3>>> DoesntBreak3; 31310152Satgutier@umich.edutypedef py::class_<BreaksBase<4>, BreaksTramp<4>> DoesntBreak4; 31410152Satgutier@umich.edutypedef py::class_<BreaksBase<5>> DoesntBreak5; 31510152Satgutier@umich.edutypedef py::class_<BreaksBase<6>, std::shared_ptr<BreaksBase<6>>, BreaksTramp<6>> DoesntBreak6; 31610152Satgutier@umich.edutypedef py::class_<BreaksBase<7>, BreaksTramp<7>, std::shared_ptr<BreaksBase<7>>> DoesntBreak7; 31710152Satgutier@umich.edutypedef py::class_<BreaksBase<8>, std::shared_ptr<BreaksBase<8>>> DoesntBreak8; 31810152Satgutier@umich.edu#define CHECK_BASE(N) static_assert(std::is_same<typename DoesntBreak##N::type, BreaksBase<N>>::value, \ 31910152Satgutier@umich.edu "DoesntBreak" #N " has wrong type!") 32010152Satgutier@umich.eduCHECK_BASE(1); CHECK_BASE(2); CHECK_BASE(3); CHECK_BASE(4); CHECK_BASE(5); CHECK_BASE(6); CHECK_BASE(7); CHECK_BASE(8); 32110152Satgutier@umich.edu#define CHECK_ALIAS(N) static_assert(DoesntBreak##N::has_alias && std::is_same<typename DoesntBreak##N::type_alias, BreaksTramp<N>>::value, \ 32210152Satgutier@umich.edu "DoesntBreak" #N " has wrong type_alias!") 32310152Satgutier@umich.edu#define CHECK_NOALIAS(N) static_assert(!DoesntBreak##N::has_alias && std::is_void<typename DoesntBreak##N::type_alias>::value, \ 32410152Satgutier@umich.edu "DoesntBreak" #N " has type alias, but shouldn't!") 32510152Satgutier@umich.eduCHECK_ALIAS(1); CHECK_ALIAS(2); CHECK_NOALIAS(3); CHECK_ALIAS(4); CHECK_NOALIAS(5); CHECK_ALIAS(6); CHECK_ALIAS(7); CHECK_NOALIAS(8); 32610152Satgutier@umich.edu#define CHECK_HOLDER(N, TYPE) static_assert(std::is_same<typename DoesntBreak##N::holder_type, std::TYPE##_ptr<BreaksBase<N>>>::value, \ 32710152Satgutier@umich.edu "DoesntBreak" #N " has wrong holder_type!") 32810152Satgutier@umich.eduCHECK_HOLDER(1, unique); CHECK_HOLDER(2, unique); CHECK_HOLDER(3, unique); CHECK_HOLDER(4, unique); CHECK_HOLDER(5, unique); 32910152Satgutier@umich.eduCHECK_HOLDER(6, shared); CHECK_HOLDER(7, shared); CHECK_HOLDER(8, shared); 33010152Satgutier@umich.edu 33110152Satgutier@umich.edu// There's no nice way to test that these fail because they fail to compile; leave them here, 33210152Satgutier@umich.edu// though, so that they can be manually tested by uncommenting them (and seeing that compilation 33310152Satgutier@umich.edu// failures occurs). 33410152Satgutier@umich.edu 33510152Satgutier@umich.edu// We have to actually look into the type: the typedef alone isn't enough to instantiate the type: 33610152Satgutier@umich.edu#define CHECK_BROKEN(N) static_assert(std::is_same<typename Breaks##N::type, BreaksBase<-N>>::value, \ 33710152Satgutier@umich.edu "Breaks1 has wrong type!"); 33810152Satgutier@umich.edu 33910152Satgutier@umich.edu//// Two holder classes: 34010152Satgutier@umich.edu//typedef py::class_<BreaksBase<-1>, std::unique_ptr<BreaksBase<-1>>, std::unique_ptr<BreaksBase<-1>>> Breaks1; 34110152Satgutier@umich.edu//CHECK_BROKEN(1); 34210152Satgutier@umich.edu//// Two aliases: 34310152Satgutier@umich.edu//typedef py::class_<BreaksBase<-2>, BreaksTramp<-2>, BreaksTramp<-2>> Breaks2; 34410152Satgutier@umich.edu//CHECK_BROKEN(2); 34510152Satgutier@umich.edu//// Holder + 2 aliases 34610152Satgutier@umich.edu//typedef py::class_<BreaksBase<-3>, std::unique_ptr<BreaksBase<-3>>, BreaksTramp<-3>, BreaksTramp<-3>> Breaks3; 34710152Satgutier@umich.edu//CHECK_BROKEN(3); 34810152Satgutier@umich.edu//// Alias + 2 holders 34910152Satgutier@umich.edu//typedef py::class_<BreaksBase<-4>, std::unique_ptr<BreaksBase<-4>>, BreaksTramp<-4>, std::shared_ptr<BreaksBase<-4>>> Breaks4; 35010152Satgutier@umich.edu//CHECK_BROKEN(4); 35110152Satgutier@umich.edu//// Invalid option (not a subclass or holder) 35210152Satgutier@umich.edu//typedef py::class_<BreaksBase<-5>, BreaksTramp<-4>> Breaks5; 35310152Satgutier@umich.edu//CHECK_BROKEN(5); 35410152Satgutier@umich.edu//// Invalid option: multiple inheritance not supported: 35510152Satgutier@umich.edu//template <> struct BreaksBase<-8> : BreaksBase<-6>, BreaksBase<-7> {}; 35610152Satgutier@umich.edu//typedef py::class_<BreaksBase<-8>, BreaksBase<-6>, BreaksBase<-7>> Breaks8; 35710152Satgutier@umich.edu//CHECK_BROKEN(8); 35810152Satgutier@umich.edu