Merge pull request #410 from wjakob/mi

WIP: Multiple inheritance support

tests/test_issues.py

@@ -65,16 +65,18 @@ def test_no_id(capture, msg):
     with pytest.raises(TypeError) as excinfo:
         get_element(None)
     assert msg(excinfo.value) == """
-        Incompatible function arguments. The following argument types are supported:
+        get_element(): incompatible function arguments. The following argument types are supported:
             1. (arg0: m.issues.ElementA) -> int
+
         Invoked with: None
     """
 
     with pytest.raises(TypeError) as excinfo:
         expect_int(5.2)
     assert msg(excinfo.value) == """
-        Incompatible function arguments. The following argument types are supported:
+        expect_int(): incompatible function arguments. The following argument types are supported:
             1. (arg0: int) -> int
+
         Invoked with: 5.2
     """
     assert expect_float(12) == 12
@@ -90,9 +92,10 @@ def test_str_issue(msg):
     with pytest.raises(TypeError) as excinfo:
         str(StrIssue("no", "such", "constructor"))
     assert msg(excinfo.value) == """
-        Incompatible constructor arguments. The following argument types are supported:
+        __init__(): incompatible constructor arguments. The following argument types are supported:
             1. m.issues.StrIssue(arg0: int)
             2. m.issues.StrIssue()
+
         Invoked with: no, such, constructor
     """
 

tests/test_kwargs_and_defaults.py

@@ -35,8 +35,9 @@ def test_named_arguments(msg):
         # noinspection PyArgumentList
         kw_func2(x=5, y=10, z=12)
     assert msg(excinfo.value) == """
-        Incompatible function arguments. The following argument types are supported:
+        kw_func2(): incompatible function arguments. The following argument types are supported:
             1. (x: int=100, y: int=200) -> str
+
         Invoked with:
     """
 

tests/test_multiple_inheritance.cpp

+/*
+    tests/test_multiple_inheritance.cpp -- multiple inheritance,
+    implicit MI casts
+
+    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"
+
+PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
+
+struct Base1 {
+    Base1(int i) : i(i) { }
+    int foo() { return i; }
+    int i;
+};
+
+struct Base2 {
+    Base2(int i) : i(i) { }
+    int bar() { return i; }
+    int i;
+};
+
+struct Base12 : Base1, Base2 {
+    Base12(int i, int j) : Base1(i), Base2(j) { }
+};
+
+struct MIType : Base12 {
+    MIType(int i, int j) : Base12(i, j) { }
+};
+
+test_initializer multiple_inheritance([](py::module &m) {
+    py::class_<Base1>(m, "Base1")
+        .def(py::init<int>())
+        .def("foo", &Base1::foo);
+
+    py::class_<Base2>(m, "Base2")
+        .def(py::init<int>())
+        .def("bar", &Base2::bar);
+
+    py::class_<Base12, Base1, Base2>(m, "Base12");
+
+    py::class_<MIType, Base12>(m, "MIType")
+        .def(py::init<int, int>());
+});
+
+/* Test the case where not all base classes are specified,
+   and where pybind11 requires the py::multiple_inheritance
+   flag to perform proper casting between types */
+
+struct Base1a {
+    Base1a(int i) : i(i) { }
+    int foo() { return i; }
+    int i;
+};
+
+struct Base2a {
+    Base2a(int i) : i(i) { }
+    int bar() { return i; }
+    int i;
+};
+
+struct Base12a : Base1a, Base2a {
+    Base12a(int i, int j) : Base1a(i), Base2a(j) { }
+};
+
+test_initializer multiple_inheritance_nonexplicit([](py::module &m) {
+    py::class_<Base1a, std::shared_ptr<Base1a>>(m, "Base1a")
+        .def(py::init<int>())
+        .def("foo", &Base1a::foo);
+
+    py::class_<Base2a, std::shared_ptr<Base2a>>(m, "Base2a")
+        .def(py::init<int>())
+        .def("bar", &Base2a::bar);
+
+    py::class_<Base12a, /* Base1 missing */ Base2a,
+               std::shared_ptr<Base12a>>(m, "Base12a", py::multiple_inheritance())
+        .def(py::init<int, int>());
+
+    m.def("bar_base2a", [](Base2a *b) { return b->bar(); });
+    m.def("bar_base2a_sharedptr", [](std::shared_ptr<Base2a> b) { return b->bar(); });
+});

tests/test_multiple_inheritance.py

+import pytest
+
+
+def test_multiple_inheritance_cpp(msg):
+    from pybind11_tests import MIType
+
+    mt = MIType(3, 4)
+
+    assert mt.foo() == 3
+    assert mt.bar() == 4
+
+
+def test_multiple_inheritance_mix1(msg):
+    from pybind11_tests import Base2
+
+    class Base1:
+        def __init__(self, i):
+            self.i = i
+
+        def foo(self):
+            return self.i
+
+    class MITypePy(Base1, Base2):
+        def __init__(self, i, j):
+            Base1.__init__(self, i)
+            Base2.__init__(self, j)
+
+    mt = MITypePy(3, 4)
+
+    assert mt.foo() == 3
+    assert mt.bar() == 4
+
+
+def test_multiple_inheritance_mix2(msg):
+    from pybind11_tests import Base1
+
+    class Base2:
+        def __init__(self, i):
+            self.i = i
+
+        def bar(self):
+            return self.i
+
+    class MITypePy(Base1, Base2):
+        def __init__(self, i, j):
+            Base1.__init__(self, i)
+            Base2.__init__(self, j)
+
+    mt = MITypePy(3, 4)
+
+    assert mt.foo() == 3
+    assert mt.bar() == 4
+
+
+def test_multiple_inheritance_virtbase(msg):
+    from pybind11_tests import Base12a, bar_base2a, bar_base2a_sharedptr
+
+    class MITypePy(Base12a):
+        def __init__(self, i, j):
+            Base12a.__init__(self, i, j)
+
+    mt = MITypePy(3, 4)
+    assert mt.bar() == 4
+    assert bar_base2a(mt) == 4
+    assert bar_base2a_sharedptr(mt) == 4

tests/test_opaque_types.py

@@ -35,8 +35,9 @@ def test_pointers(msg):
     with pytest.raises(TypeError) as excinfo:
         get_void_ptr_value([1, 2, 3])  # This should not work
     assert msg(excinfo.value) == """
-        Incompatible function arguments. The following argument types are supported:
+        get_void_ptr_value(): incompatible function arguments. The following argument types are supported:
             1. (arg0: capsule) -> int
+
         Invoked with: [1, 2, 3]
     """