test_multiple_inheritance.py 8.93 KB
Newer Older
1
import pytest
2
from pybind11_tests import ConstructorStats
3
from pybind11_tests import multiple_inheritance as m
4
5


6
def test_multiple_inheritance_cpp():
7
    mt = m.MIType(3, 4)
Wenzel Jakob's avatar
Wenzel Jakob committed
8
9
10
11
12

    assert mt.foo() == 3
    assert mt.bar() == 4


13
def test_multiple_inheritance_mix1():
Wenzel Jakob's avatar
Wenzel Jakob committed
14
15
16
17
18
19
20
    class Base1:
        def __init__(self, i):
            self.i = i

        def foo(self):
            return self.i

21
    class MITypePy(Base1, m.Base2):
Wenzel Jakob's avatar
Wenzel Jakob committed
22
23
        def __init__(self, i, j):
            Base1.__init__(self, i)
24
            m.Base2.__init__(self, j)
Wenzel Jakob's avatar
Wenzel Jakob committed
25
26
27
28
29
30
31

    mt = MITypePy(3, 4)

    assert mt.foo() == 3
    assert mt.bar() == 4


32
def test_multiple_inheritance_mix2():
Wenzel Jakob's avatar
Wenzel Jakob committed
33
34
35
36
37
38
39
40

    class Base2:
        def __init__(self, i):
            self.i = i

        def bar(self):
            return self.i

41
    class MITypePy(m.Base1, Base2):
Wenzel Jakob's avatar
Wenzel Jakob committed
42
        def __init__(self, i, j):
43
            m.Base1.__init__(self, i)
Wenzel Jakob's avatar
Wenzel Jakob committed
44
45
46
47
48
49
50
51
            Base2.__init__(self, j)

    mt = MITypePy(3, 4)

    assert mt.foo() == 3
    assert mt.bar() == 4


52
def test_multiple_inheritance_python():
53

54
    class MI1(m.Base1, m.Base2):
55
        def __init__(self, i, j):
56
57
            m.Base1.__init__(self, i)
            m.Base2.__init__(self, j)
58
59
60
61
62

    class B1(object):
        def v(self):
            return 1

63
    class MI2(B1, m.Base1, m.Base2):
64
65
        def __init__(self, i, j):
            B1.__init__(self)
66
67
            m.Base1.__init__(self, i)
            m.Base2.__init__(self, j)
68
69
70
71
72

    class MI3(MI2):
        def __init__(self, i, j):
            MI2.__init__(self, i, j)

73
    class MI4(MI3, m.Base2):
74
        def __init__(self, i, j, k):
Jason Rhinelander's avatar
Jason Rhinelander committed
75
            MI3.__init__(self, j, k)
76
            m.Base2.__init__(self, i)
77

78
    class MI5(m.Base2, B1, m.Base1):
79
80
        def __init__(self, i, j):
            B1.__init__(self)
81
82
            m.Base1.__init__(self, i)
            m.Base2.__init__(self, j)
83

84
    class MI6(m.Base2, B1):
85
        def __init__(self, i):
86
            m.Base2.__init__(self, i)
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
            B1.__init__(self)

    class B2(B1):
        def v(self):
            return 2

    class B3(object):
        def v(self):
            return 3

    class B4(B3, B2):
        def v(self):
            return 4

    class MI7(B4, MI6):
        def __init__(self, i):
            B4.__init__(self)
            MI6.__init__(self, i)

    class MI8(MI6, B3):
        def __init__(self, i):
            MI6.__init__(self, i)
            B3.__init__(self)

    class MI8b(B3, MI6):
        def __init__(self, i):
            B3.__init__(self)
            MI6.__init__(self, i)

    mi1 = MI1(1, 2)
    assert mi1.foo() == 1
    assert mi1.bar() == 2

    mi2 = MI2(3, 4)
    assert mi2.v() == 1
    assert mi2.foo() == 3
    assert mi2.bar() == 4

    mi3 = MI3(5, 6)
    assert mi3.v() == 1
    assert mi3.foo() == 5
    assert mi3.bar() == 6

    mi4 = MI4(7, 8, 9)
    assert mi4.v() == 1
    assert mi4.foo() == 8
    assert mi4.bar() == 7

    mi5 = MI5(10, 11)
    assert mi5.v() == 1
    assert mi5.foo() == 10
    assert mi5.bar() == 11

    mi6 = MI6(12)
    assert mi6.v() == 1
    assert mi6.bar() == 12

    mi7 = MI7(13)
    assert mi7.v() == 4
    assert mi7.bar() == 13

    mi8 = MI8(14)
    assert mi8.v() == 1
    assert mi8.bar() == 14

    mi8b = MI8b(15)
    assert mi8b.v() == 3
    assert mi8b.bar() == 15


def test_multiple_inheritance_python_many_bases():

159
    class MIMany14(m.BaseN1, m.BaseN2, m.BaseN3, m.BaseN4):
160
        def __init__(self):
161
162
163
164
            m.BaseN1.__init__(self, 1)
            m.BaseN2.__init__(self, 2)
            m.BaseN3.__init__(self, 3)
            m.BaseN4.__init__(self, 4)
165

166
    class MIMany58(m.BaseN5, m.BaseN6, m.BaseN7, m.BaseN8):
167
        def __init__(self):
168
169
170
171
            m.BaseN5.__init__(self, 5)
            m.BaseN6.__init__(self, 6)
            m.BaseN7.__init__(self, 7)
            m.BaseN8.__init__(self, 8)
172

173
174
    class MIMany916(m.BaseN9, m.BaseN10, m.BaseN11, m.BaseN12, m.BaseN13, m.BaseN14, m.BaseN15,
                    m.BaseN16):
175
        def __init__(self):
176
177
178
179
180
181
182
183
184
185
            m.BaseN9.__init__(self, 9)
            m.BaseN10.__init__(self, 10)
            m.BaseN11.__init__(self, 11)
            m.BaseN12.__init__(self, 12)
            m.BaseN13.__init__(self, 13)
            m.BaseN14.__init__(self, 14)
            m.BaseN15.__init__(self, 15)
            m.BaseN16.__init__(self, 16)

    class MIMany19(MIMany14, MIMany58, m.BaseN9):
186
187
188
        def __init__(self):
            MIMany14.__init__(self)
            MIMany58.__init__(self)
189
            m.BaseN9.__init__(self, 9)
190

191
    class MIMany117(MIMany14, MIMany58, MIMany916, m.BaseN17):
192
193
194
195
        def __init__(self):
            MIMany14.__init__(self)
            MIMany58.__init__(self)
            MIMany916.__init__(self)
196
            m.BaseN17.__init__(self, 17)
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

    # Inherits from 4 registered C++ classes: can fit in one pointer on any modern arch:
    a = MIMany14()
    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 = MIMany916()
    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 = MIMany19()
    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 = MIMany117()
    for i in range(1, 17):
        assert getattr(d, "f" + str(i))() == 2 * i
217
218


219
def test_multiple_inheritance_virtbase():
Wenzel Jakob's avatar
Wenzel Jakob committed
220

221
    class MITypePy(m.Base12a):
Wenzel Jakob's avatar
Wenzel Jakob committed
222
        def __init__(self, i, j):
223
            m.Base12a.__init__(self, i, j)
Wenzel Jakob's avatar
Wenzel Jakob committed
224
225
226

    mt = MITypePy(3, 4)
    assert mt.bar() == 4
227
228
    assert m.bar_base2a(mt) == 4
    assert m.bar_base2a_sharedptr(mt) == 4
229
230
231
232
233
234


def test_mi_static_properties():
    """Mixing bases with and without static properties should be possible
     and the result should be independent of base definition order"""

235
    for d in (m.VanillaStaticMix1(), m.VanillaStaticMix2()):
236
237
238
239
240
        assert d.vanilla() == "Vanilla"
        assert d.static_func1() == "WithStatic1"
        assert d.static_func2() == "WithStatic2"
        assert d.static_func() == d.__class__.__name__

241
242
        m.WithStatic1.static_value1 = 1
        m.WithStatic2.static_value2 = 2
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
        assert d.static_value1 == 1
        assert d.static_value2 == 2
        assert d.static_value == 12

        d.static_value1 = 0
        assert d.static_value1 == 0
        d.static_value2 = 0
        assert d.static_value2 == 0
        d.static_value = 0
        assert d.static_value == 0


@pytest.unsupported_on_pypy
def test_mi_dynamic_attributes():
    """Mixing bases with and without dynamic attribute support"""

259
    for d in (m.VanillaDictMix1(), m.VanillaDictMix2()):
260
261
        d.dynamic = 1
        assert d.dynamic == 1
262
263


264
265
266
267
268
def test_mi_unaligned_base():
    """Returning an offset (non-first MI) base class pointer should recognize the instance"""

    n_inst = ConstructorStats.detail_reg_inst()

269
270
    c = m.I801C()
    d = m.I801D()
271
272
    # + 4 below because we have the two instances, and each instance has offset base I801B2
    assert ConstructorStats.detail_reg_inst() == n_inst + 4
273
    b1c = m.i801b1_c(c)
274
    assert b1c is c
275
    b2c = m.i801b2_c(c)
276
    assert b2c is c
277
    b1d = m.i801b1_d(d)
278
    assert b1d is d
279
    b2d = m.i801b2_d(d)
280
281
282
283
284
285
286
287
288
    assert b2d is d

    assert ConstructorStats.detail_reg_inst() == n_inst + 4  # no extra instances
    del c, b1c, b2c
    assert ConstructorStats.detail_reg_inst() == n_inst + 2
    del d, b1d, b2d
    assert ConstructorStats.detail_reg_inst() == n_inst


289
290
291
292
293
def test_mi_base_return():
    """Tests returning an offset (non-first MI) base class pointer to a derived instance"""

    n_inst = ConstructorStats.detail_reg_inst()

294
295
    c1 = m.i801c_b1()
    assert type(c1) is m.I801C
296
297
298
    assert c1.a == 1
    assert c1.b == 2

299
300
    d1 = m.i801d_b1()
    assert type(d1) is m.I801D
301
302
303
    assert d1.a == 1
    assert d1.b == 2

304
    assert ConstructorStats.detail_reg_inst() == n_inst + 4
305

306
307
    c2 = m.i801c_b2()
    assert type(c2) is m.I801C
308
309
310
    assert c2.a == 1
    assert c2.b == 2

311
312
    d2 = m.i801d_b2()
    assert type(d2) is m.I801D
313
314
315
    assert d2.a == 1
    assert d2.b == 2

316
    assert ConstructorStats.detail_reg_inst() == n_inst + 8
317
318

    del c2
319
    assert ConstructorStats.detail_reg_inst() == n_inst + 6
320
321
322
323
324
325
    del c1, d1, d2
    assert ConstructorStats.detail_reg_inst() == n_inst

    # Returning an unregistered derived type with a registered base; we won't
    # pick up the derived type, obviously, but should still work (as an object
    # of whatever type was returned).
326
327
    e1 = m.i801e_c()
    assert type(e1) is m.I801C
328
329
330
    assert e1.a == 1
    assert e1.b == 2

331
332
    e2 = m.i801e_b2()
    assert type(e2) is m.I801B2
333
    assert e2.b == 2
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348


def test_diamond_inheritance():
    """Tests that diamond inheritance works as expected (issue #959)"""

    # Issue #959: this shouldn't segfault:
    d = m.D()

    # Make sure all the various distinct pointers are all recognized as registered instances:
    assert d is d.c0()
    assert d is d.c1()
    assert d is d.b()
    assert d is d.c0().b()
    assert d is d.c1().b()
    assert d is d.c0().c1().b().c0().b()