mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-13 17:13:53 +00:00
52f4be8946
Adding or removing tests is a little bit cumbersome currently: the test needs to be added to CMakeLists.txt, the init function needs to be predeclared in pybind11_tests.cpp, then called in the plugin initialization. While this isn't a big deal for tests that are being committed, it's more of a hassle when working on some new feature or test code for which I temporarily only care about building and linking the test being worked on rather than the entire test suite. This commit changes tests to self-register their initialization by having each test initialize a local object (which stores the initialization function in a static variable). This makes changing the set of tests being build easy: one only needs to add or comment out test names in tests/CMakeLists.txt. A couple other minor changes that go along with this: - test_eigen.cpp is now included in the test list, then removed if eigen isn't available. This lets you disable the eigen tests by commenting it out, just like all the other tests, but keeps the build working without eigen eigen isn't available. (Also, if it's commented out, we don't even bother looking for and reporting the building with/without eigen status message). - pytest is now invoked with all the built test names (with .cpp changed to .py) so that it doesn't try to run tests that weren't built.
73 lines
2.2 KiB
C++
73 lines
2.2 KiB
C++
/*
|
|
tests/test_inheritance.cpp -- inheritance, automatic upcasting for polymorphic types
|
|
|
|
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.
|
|
*/
|
|
|
|
#include "pybind11_tests.h"
|
|
|
|
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; }
|
|
private:
|
|
std::string m_name;
|
|
std::string m_species;
|
|
};
|
|
|
|
class Dog : public Pet {
|
|
public:
|
|
Dog(const std::string &name) : Pet(name, "dog") {}
|
|
std::string bark() const { return "Woof!"; }
|
|
};
|
|
|
|
class Rabbit : public Pet {
|
|
public:
|
|
Rabbit(const std::string &name) : Pet(name, "parrot") {}
|
|
};
|
|
|
|
std::string pet_name_species(const Pet &pet) {
|
|
return pet.name() + " is a " + pet.species();
|
|
}
|
|
|
|
std::string dog_bark(const Dog &dog) {
|
|
return dog.bark();
|
|
}
|
|
|
|
|
|
struct BaseClass { virtual ~BaseClass() {} };
|
|
struct DerivedClass1 : BaseClass { };
|
|
struct DerivedClass2 : BaseClass { };
|
|
|
|
test_initializer inheritance([](py::module &m) {
|
|
py::class_<Pet> pet_class(m, "Pet");
|
|
pet_class
|
|
.def(py::init<std::string, std::string>())
|
|
.def("name", &Pet::name)
|
|
.def("species", &Pet::species);
|
|
|
|
/* One way of declaring a subclass relationship: reference parent's class_ object */
|
|
py::class_<Dog>(m, "Dog", pet_class)
|
|
.def(py::init<std::string>());
|
|
|
|
/* Another way of declaring a subclass relationship: reference parent's C++ type */
|
|
py::class_<Rabbit>(m, "Rabbit", py::base<Pet>())
|
|
.def(py::init<std::string>());
|
|
|
|
m.def("pet_name_species", pet_name_species);
|
|
m.def("dog_bark", dog_bark);
|
|
|
|
py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
|
|
py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
|
|
py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());
|
|
|
|
m.def("return_class_1", []() -> BaseClass* { return new DerivedClass1(); });
|
|
m.def("return_class_2", []() -> BaseClass* { return new DerivedClass2(); });
|
|
m.def("return_none", []() -> BaseClass* { return nullptr; });
|
|
});
|