test_multiple_inheritance.py 9.05 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


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

        def foo(self):
            return self.i

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

    mt = MITypePy(3, 4)

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


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

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

        def bar(self):
            return self.i

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

    mt = MITypePy(3, 4)

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


Isuru Fernando's avatar
Isuru Fernando committed
53
@pytest.bug_in_pypy
54
def test_multiple_inheritance_python():
55

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

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

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

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

75
    class MI4(MI3, m.Base2):
76
77
        def __init__(self, i, j):
            MI3.__init__(self, i, j)
78
79
            # This should be ignored (Base2 is already initialized via MI2):
            m.Base2.__init__(self, i + 100)
80

81
    class MI5(m.Base2, B1, m.Base1):
82
83
        def __init__(self, i, j):
            B1.__init__(self)
84
85
            m.Base1.__init__(self, i)
            m.Base2.__init__(self, j)
86

87
    class MI6(m.Base2, B1):
88
        def __init__(self, i):
89
            m.Base2.__init__(self, i)
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
            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

133
    mi4 = MI4(7, 8)
134
    assert mi4.v() == 1
135
136
    assert mi4.foo() == 7
    assert mi4.bar() == 8
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

    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():

162
    class MIMany14(m.BaseN1, m.BaseN2, m.BaseN3, m.BaseN4):
163
        def __init__(self):
164
165
166
167
            m.BaseN1.__init__(self, 1)
            m.BaseN2.__init__(self, 2)
            m.BaseN3.__init__(self, 3)
            m.BaseN4.__init__(self, 4)
168

169
    class MIMany58(m.BaseN5, m.BaseN6, m.BaseN7, m.BaseN8):
170
        def __init__(self):
171
172
173
174
            m.BaseN5.__init__(self, 5)
            m.BaseN6.__init__(self, 6)
            m.BaseN7.__init__(self, 7)
            m.BaseN8.__init__(self, 8)
175

176
177
    class MIMany916(m.BaseN9, m.BaseN10, m.BaseN11, m.BaseN12, m.BaseN13, m.BaseN14, m.BaseN15,
                    m.BaseN16):
178
        def __init__(self):
179
180
181
182
183
184
185
186
187
188
            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):
189
190
191
        def __init__(self):
            MIMany14.__init__(self)
            MIMany58.__init__(self)
192
            m.BaseN9.__init__(self, 9)
193

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

    # 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
220
221


222
def test_multiple_inheritance_virtbase():
Wenzel Jakob's avatar
Wenzel Jakob committed
223

224
    class MITypePy(m.Base12a):
Wenzel Jakob's avatar
Wenzel Jakob committed
225
        def __init__(self, i, j):
226
            m.Base12a.__init__(self, i, j)
Wenzel Jakob's avatar
Wenzel Jakob committed
227
228
229

    mt = MITypePy(3, 4)
    assert mt.bar() == 4
230
231
    assert m.bar_base2a(mt) == 4
    assert m.bar_base2a_sharedptr(mt) == 4
232
233
234
235
236
237


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"""

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

244
245
        m.WithStatic1.static_value1 = 1
        m.WithStatic2.static_value2 = 2
246
247
248
249
250
251
252
253
254
255
256
257
        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


Isuru Fernando's avatar
Isuru Fernando committed
258
@pytest.unsupported_on_pypy_lt_6
259
260
261
def test_mi_dynamic_attributes():
    """Mixing bases with and without dynamic attribute support"""

262
    for d in (m.VanillaDictMix1(), m.VanillaDictMix2()):
263
264
        d.dynamic = 1
        assert d.dynamic == 1
265
266


267
268
269
270
271
def test_mi_unaligned_base():
    """Returning an offset (non-first MI) base class pointer should recognize the instance"""

    n_inst = ConstructorStats.detail_reg_inst()

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


292
293
294
295
296
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()

297
298
    c1 = m.i801c_b1()
    assert type(c1) is m.I801C
299
300
301
    assert c1.a == 1
    assert c1.b == 2

302
303
    d1 = m.i801d_b1()
    assert type(d1) is m.I801D
304
305
306
    assert d1.a == 1
    assert d1.b == 2

307
    assert ConstructorStats.detail_reg_inst() == n_inst + 4
308

309
310
    c2 = m.i801c_b2()
    assert type(c2) is m.I801C
311
312
313
    assert c2.a == 1
    assert c2.b == 2

314
315
    d2 = m.i801d_b2()
    assert type(d2) is m.I801D
316
317
318
    assert d2.a == 1
    assert d2.b == 2

319
    assert ConstructorStats.detail_reg_inst() == n_inst + 8
320
321

    del c2
322
    assert ConstructorStats.detail_reg_inst() == n_inst + 6
323
324
325
326
327
328
    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).
329
330
    e1 = m.i801e_c()
    assert type(e1) is m.I801C
331
332
333
    assert e1.a == 1
    assert e1.b == 2

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


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()