mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-11 08:03:55 +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.
59 lines
1.8 KiB
C++
59 lines
1.8 KiB
C++
/*
|
|
tests/test_modules.cpp -- nested modules, importing modules, and
|
|
internal references
|
|
|
|
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"
|
|
#include "constructor_stats.h"
|
|
|
|
std::string submodule_func() {
|
|
return "submodule_func()";
|
|
}
|
|
|
|
class A {
|
|
public:
|
|
A(int v) : v(v) { print_created(this, v); }
|
|
~A() { print_destroyed(this); }
|
|
A(const A&) { print_copy_created(this); }
|
|
A& operator=(const A ©) { print_copy_assigned(this); v = copy.v; return *this; }
|
|
std::string toString() { return "A[" + std::to_string(v) + "]"; }
|
|
private:
|
|
int v;
|
|
};
|
|
|
|
class B {
|
|
public:
|
|
B() { print_default_created(this); }
|
|
~B() { print_destroyed(this); }
|
|
B(const B&) { print_copy_created(this); }
|
|
B& operator=(const B ©) { print_copy_assigned(this); a1 = copy.a1; a2 = copy.a2; return *this; }
|
|
A &get_a1() { return a1; }
|
|
A &get_a2() { return a2; }
|
|
|
|
A a1{1};
|
|
A a2{2};
|
|
};
|
|
|
|
test_initializer modules([](py::module &m) {
|
|
py::module m_sub = m.def_submodule("submodule");
|
|
m_sub.def("submodule_func", &submodule_func);
|
|
|
|
py::class_<A>(m_sub, "A")
|
|
.def(py::init<int>())
|
|
.def("__repr__", &A::toString);
|
|
|
|
py::class_<B>(m_sub, "B")
|
|
.def(py::init<>())
|
|
.def("get_a1", &B::get_a1, "Return the internal A 1", py::return_value_policy::reference_internal)
|
|
.def("get_a2", &B::get_a2, "Return the internal A 2", py::return_value_policy::reference_internal)
|
|
.def_readwrite("a1", &B::a1) // def_readonly uses an internal reference return policy by default
|
|
.def_readwrite("a2", &B::a2);
|
|
|
|
m.attr("OD") = py::module::import("collections").attr("OrderedDict");
|
|
});
|