Add many-inheritance test

This tests that multiple inheritance is working properly when it
requires multiple blocks for holder-constructed flags (i.e. for a Python
class that, through direct or indirect Python-side inheritance, inherits
from more than `sizeof(void *)` registered classes).

Author: jagerman

tests/test_multiple_inheritance.cpp

@@ -23,6 +23,11 @@ struct Base2 {
     int i;
 };
 
+template <int N> struct BaseN {
+    BaseN(int i) : i(i) { }
+    int i;
+};
+
 struct Base12 : Base1, Base2 {
     Base12(int i, int j) : Base1(i), Base2(j) { }
 };
@@ -45,6 +50,15 @@ test_initializer multiple_inheritance([](py::module &m) {
     py::class_<MIType, Base12>(m, "MIType")
         .def(py::init<int, int>());
 
+    // Many bases for testing that multiple inheritance from many classes (i.e. requiring extra
+    // space for holder constructed flags) works.
+    #define PYBIND11_BASEN(N) py::class_<BaseN<N>>(m, "BaseN" #N).def(py::init<int>()).def("f" #N, [](BaseN<N> &b) { return b.i + N; })
+    PYBIND11_BASEN( 1); PYBIND11_BASEN( 2); PYBIND11_BASEN( 3); PYBIND11_BASEN( 4);
+    PYBIND11_BASEN( 5); PYBIND11_BASEN( 6); PYBIND11_BASEN( 7); PYBIND11_BASEN( 8);
+    PYBIND11_BASEN( 9); PYBIND11_BASEN(10); PYBIND11_BASEN(11); PYBIND11_BASEN(12);
+    PYBIND11_BASEN(13); PYBIND11_BASEN(14); PYBIND11_BASEN(15); PYBIND11_BASEN(16);
+    PYBIND11_BASEN(17);
+
     // Uncommenting this should result in a compile time failure (MI can only be specified via
     // template parameters because pybind has to know the types involved; see discussion in #742 for
     // details).

tests/test_multiple_inheritance.py

@@ -159,6 +159,70 @@ def __init__(self, i):
     assert mi8b.bar() == 15
 
 
+def test_multiple_inheritance_python_many_bases():
+    from pybind11_tests import (BaseN1,  BaseN2,  BaseN3,  BaseN4,  BaseN5,  BaseN6,  BaseN7,
+                                BaseN8,  BaseN9,  BaseN10, BaseN11, BaseN12, BaseN13, BaseN14,
+                                BaseN15, BaseN16, BaseN17)
+
+    class MIMany1_4(BaseN1, BaseN2, BaseN3, BaseN4):
+        def __init__(self):
+            BaseN1.__init__(self, 1)
+            BaseN2.__init__(self, 2)
+            BaseN3.__init__(self, 3)
+            BaseN4.__init__(self, 4)
+
+    class MIMany5_8(BaseN5, BaseN6, BaseN7, BaseN8):
+        def __init__(self):
+            BaseN5.__init__(self, 5)
+            BaseN6.__init__(self, 6)
+            BaseN7.__init__(self, 7)
+            BaseN8.__init__(self, 8)
+
+    class MIMany9_16(BaseN9, BaseN10, BaseN11, BaseN12, BaseN13, BaseN14, BaseN15, BaseN16):
+        def __init__(self):
+            BaseN9.__init__(self, 9)
+            BaseN10.__init__(self, 10)
+            BaseN11.__init__(self, 11)
+            BaseN12.__init__(self, 12)
+            BaseN13.__init__(self, 13)
+            BaseN14.__init__(self, 14)
+            BaseN15.__init__(self, 15)
+            BaseN16.__init__(self, 16)
+
+    class MIMany1_9(MIMany1_4, MIMany5_8, BaseN9):
+        def __init__(self):
+            MIMany1_4.__init__(self)
+            MIMany5_8.__init__(self)
+            BaseN9.__init__(self, 9)
+
+    class MIMany1_17(MIMany1_4, MIMany5_8, MIMany9_16, BaseN17):
+        def __init__(self):
+            MIMany1_4.__init__(self)
+            MIMany5_8.__init__(self)
+            MIMany9_16.__init__(self)
+            BaseN17.__init__(self, 17)
+
+    # Inherits from 4 registered C++ classes: can fit in one pointer on any modern arch:
+    a = MIMany1_4()
+    for i in range(1, 4):
+        assert getattr(a, "f" + str(i))() == 2 * i
+
+    # Inherits from 8: requires 1/2 pointers worth of holder flags on 32/64-bit arch:
+    b = MIMany9_16()
+    for i in range(9, 16):
+        assert getattr(b, "f" + str(i))() == 2 * i
+
+    # Inherits from 9: requires >= 2 pointers worth of holder flags
+    c = MIMany1_9()
+    for i in range(1, 9):
+        assert getattr(c, "f" + str(i))() == 2 * i
+
+    # Inherits from 17: requires >= 3 pointers worth of holder flags
+    d = MIMany1_17()
+    for i in range(1, 17):
+        assert getattr(d, "f" + str(i))() == 2 * i
+
+
 def test_multiple_inheritance_virtbase():
     from pybind11_tests import Base12a, bar_base2a, bar_base2a_sharedptr