test_methods_and_attributes.py 16.3 KB
Newer Older
1
# -*- coding: utf-8 -*-
Dean Moldovan's avatar
Dean Moldovan committed
2
import pytest
3
4
5

import env  # noqa: F401

6
7
from pybind11_tests import methods_and_attributes as m
from pybind11_tests import ConstructorStats
Dean Moldovan's avatar
Dean Moldovan committed
8
9
10


def test_methods_and_attributes():
11
12
    instance1 = m.ExampleMandA()
    instance2 = m.ExampleMandA(32)
Dean Moldovan's avatar
Dean Moldovan committed
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

    instance1.add1(instance2)
    instance1.add2(instance2)
    instance1.add3(instance2)
    instance1.add4(instance2)
    instance1.add5(instance2)
    instance1.add6(32)
    instance1.add7(32)
    instance1.add8(32)
    instance1.add9(32)
    instance1.add10(32)

    assert str(instance1) == "ExampleMandA[value=320]"
    assert str(instance2) == "ExampleMandA[value=32]"
    assert str(instance1.self1()) == "ExampleMandA[value=320]"
    assert str(instance1.self2()) == "ExampleMandA[value=320]"
    assert str(instance1.self3()) == "ExampleMandA[value=320]"
    assert str(instance1.self4()) == "ExampleMandA[value=320]"
    assert str(instance1.self5()) == "ExampleMandA[value=320]"

    assert instance1.internal1() == 320
    assert instance1.internal2() == 320
    assert instance1.internal3() == 320
    assert instance1.internal4() == 320
    assert instance1.internal5() == 320

39
40
    assert instance1.overloaded() == "()"
    assert instance1.overloaded(0) == "(int)"
41
42
    assert instance1.overloaded(1, 1.0) == "(int, float)"
    assert instance1.overloaded(2.0, 2) == "(float, int)"
43
44
    assert instance1.overloaded(3, 3) == "(int, int)"
    assert instance1.overloaded(4.0, 4.0) == "(float, float)"
45
    assert instance1.overloaded_const(-3) == "(int) const"
46
47
    assert instance1.overloaded_const(5, 5.0) == "(int, float) const"
    assert instance1.overloaded_const(6.0, 6) == "(float, int) const"
48
49
    assert instance1.overloaded_const(7, 7) == "(int, int) const"
    assert instance1.overloaded_const(8.0, 8.0) == "(float, float) const"
50
    assert instance1.overloaded_float(1, 1) == "(float, float)"
51
52
53
    assert instance1.overloaded_float(1, 1.0) == "(float, float)"
    assert instance1.overloaded_float(1.0, 1) == "(float, float)"
    assert instance1.overloaded_float(1.0, 1.0) == "(float, float)"
54

Dean Moldovan's avatar
Dean Moldovan committed
55
56
57
58
    assert instance1.value == 320
    instance1.value = 100
    assert str(instance1) == "ExampleMandA[value=100]"

59
    cstats = ConstructorStats.get(m.ExampleMandA)
Dean Moldovan's avatar
Dean Moldovan committed
60
61
62
63
64
    assert cstats.alive() == 2
    del instance1, instance2
    assert cstats.alive() == 0
    assert cstats.values() == ["32"]
    assert cstats.default_constructions == 1
65
66
    assert cstats.copy_constructions == 2
    assert cstats.move_constructions >= 2
Dean Moldovan's avatar
Dean Moldovan committed
67
68
    assert cstats.copy_assignments == 0
    assert cstats.move_assignments == 0
Dean Moldovan's avatar
Dean Moldovan committed
69
70


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
def test_copy_method():
    """Issue #443: calling copied methods fails in Python 3"""

    m.ExampleMandA.add2c = m.ExampleMandA.add2
    m.ExampleMandA.add2d = m.ExampleMandA.add2b
    a = m.ExampleMandA(123)
    assert a.value == 123
    a.add2(m.ExampleMandA(-100))
    assert a.value == 23
    a.add2b(m.ExampleMandA(20))
    assert a.value == 43
    a.add2c(m.ExampleMandA(6))
    assert a.value == 49
    a.add2d(m.ExampleMandA(-7))
    assert a.value == 42
86

87
88
89

def test_properties():
    instance = m.TestProperties()
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

    assert instance.def_readonly == 1
    with pytest.raises(AttributeError):
        instance.def_readonly = 2

    instance.def_readwrite = 2
    assert instance.def_readwrite == 2

    assert instance.def_property_readonly == 2
    with pytest.raises(AttributeError):
        instance.def_property_readonly = 3

    instance.def_property = 3
    assert instance.def_property == 3

105
106
    with pytest.raises(AttributeError) as excinfo:
        dummy = instance.def_property_writeonly  # noqa: F841 unused var
107
    assert "unreadable attribute" in str(excinfo.value)
108
109
110
111
112
113

    instance.def_property_writeonly = 4
    assert instance.def_property_readonly == 4

    with pytest.raises(AttributeError) as excinfo:
        dummy = instance.def_property_impossible  # noqa: F841 unused var
114
    assert "unreadable attribute" in str(excinfo.value)
115
116
117

    with pytest.raises(AttributeError) as excinfo:
        instance.def_property_impossible = 5
118
    assert "can't set attribute" in str(excinfo.value)
119

120
121

def test_static_properties():
122
    assert m.TestProperties.def_readonly_static == 1
123
    with pytest.raises(AttributeError) as excinfo:
124
        m.TestProperties.def_readonly_static = 2
125
    assert "can't set attribute" in str(excinfo.value)
126

127
128
    m.TestProperties.def_readwrite_static = 2
    assert m.TestProperties.def_readwrite_static == 2
129

130
    with pytest.raises(AttributeError) as excinfo:
131
        dummy = m.TestProperties.def_writeonly_static  # noqa: F841 unused var
132
    assert "unreadable attribute" in str(excinfo.value)
133
134
135
136
137
138
139

    m.TestProperties.def_writeonly_static = 3
    assert m.TestProperties.def_readonly_static == 3

    assert m.TestProperties.def_property_readonly_static == 3
    with pytest.raises(AttributeError) as excinfo:
        m.TestProperties.def_property_readonly_static = 99
140
    assert "can't set attribute" in str(excinfo.value)
141

142
143
144
145
146
    m.TestProperties.def_property_static = 4
    assert m.TestProperties.def_property_static == 4

    with pytest.raises(AttributeError) as excinfo:
        dummy = m.TestProperties.def_property_writeonly_static
147
    assert "unreadable attribute" in str(excinfo.value)
148
149
150

    m.TestProperties.def_property_writeonly_static = 5
    assert m.TestProperties.def_property_static == 5
151

152
    # Static property read and write via instance
153
    instance = m.TestProperties()
154

155
156
    m.TestProperties.def_readwrite_static = 0
    assert m.TestProperties.def_readwrite_static == 0
157
158
159
    assert instance.def_readwrite_static == 0

    instance.def_readwrite_static = 2
160
    assert m.TestProperties.def_readwrite_static == 2
161
162
    assert instance.def_readwrite_static == 2

163
164
    with pytest.raises(AttributeError) as excinfo:
        dummy = instance.def_property_writeonly_static  # noqa: F841 unused var
165
    assert "unreadable attribute" in str(excinfo.value)
166
167
168
169

    instance.def_property_writeonly_static = 4
    assert instance.def_property_static == 4

170
    # It should be possible to override properties in derived classes
171
172
    assert m.TestPropertiesOverride().def_readonly == 99
    assert m.TestPropertiesOverride.def_readonly_static == 99
173

174
175
176
177

def test_static_cls():
    """Static property getter and setters expect the type object as the their only argument"""

178
179
180
    instance = m.TestProperties()
    assert m.TestProperties.static_cls is m.TestProperties
    assert instance.static_cls is m.TestProperties
181
182

    def check_self(self):
183
        assert self is m.TestProperties
184

185
    m.TestProperties.static_cls = check_self
186
187
    instance.static_cls = check_self

188

189
190
191
def test_metaclass_override():
    """Overriding pybind11's default metaclass changes the behavior of `static_property`"""

192
193
    assert type(m.ExampleMandA).__name__ == "pybind11_type"
    assert type(m.MetaclassOverride).__name__ == "type"
194

195
    assert m.MetaclassOverride.readonly == 1
196
197
198
199
    assert (
        type(m.MetaclassOverride.__dict__["readonly"]).__name__
        == "pybind11_static_property"
    )
200
201

    # Regular `type` replaces the property instead of calling `__set__()`
202
203
204
    m.MetaclassOverride.readonly = 2
    assert m.MetaclassOverride.readonly == 2
    assert isinstance(m.MetaclassOverride.__dict__["readonly"], int)
205
206


207
208
209
210
def test_no_mixed_overloads():
    from pybind11_tests import debug_enabled

    with pytest.raises(RuntimeError) as excinfo:
211
        m.ExampleMandA.add_mixed_overloads1()
212
213
214
215
216
217
218
219
    assert str(
        excinfo.value
    ) == "overloading a method with both static and instance methods is not supported; " + (
        "compile in debug mode for more details"
        if not debug_enabled
        else "error while attempting to bind static method ExampleMandA.overload_mixed1"
        "(arg0: float) -> str"
    )
220
221

    with pytest.raises(RuntimeError) as excinfo:
222
        m.ExampleMandA.add_mixed_overloads2()
223
224
225
226
227
228
229
230
231
    assert str(
        excinfo.value
    ) == "overloading a method with both static and instance methods is not supported; " + (
        "compile in debug mode for more details"
        if not debug_enabled
        else "error while attempting to bind instance method ExampleMandA.overload_mixed2"
        "(self: pybind11_tests.methods_and_attributes.ExampleMandA, arg0: int, arg1: int)"
        " -> str"
    )
232
233


234
235
236
@pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"])
def test_property_return_value_policies(access):
    if not access.startswith("static"):
237
        obj = m.TestPropRVP()
238
    else:
239
        obj = m.TestPropRVP
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

    ref = getattr(obj, access + "_ref")
    assert ref.value == 1
    ref.value = 2
    assert getattr(obj, access + "_ref").value == 2
    ref.value = 1  # restore original value for static properties

    copy = getattr(obj, access + "_copy")
    assert copy.value == 1
    copy.value = 2
    assert getattr(obj, access + "_copy").value == 1

    copy = getattr(obj, access + "_func")
    assert copy.value == 1
    copy.value = 2
    assert getattr(obj, access + "_func").value == 1


def test_property_rvalue_policy():
    """When returning an rvalue, the return value policy is automatically changed from
260
    `reference(_internal)` to `move`. The following would not work otherwise."""
261

262
    instance = m.TestPropRVP()
263
264
    o = instance.rvalue
    assert o.value == 1
Wenzel Jakob's avatar
Wenzel Jakob committed
265

266
267
    os = m.TestPropRVP.static_rvalue
    assert os.value == 1
268
269


270
271
# https://foss.heptapod.net/pypy/pypy/-/issues/2447
@pytest.mark.xfail("env.PYPY")
Dean Moldovan's avatar
Dean Moldovan committed
272
def test_dynamic_attributes():
273
    instance = m.DynamicClass()
Dean Moldovan's avatar
Dean Moldovan committed
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
    assert not hasattr(instance, "foo")
    assert "foo" not in dir(instance)

    # Dynamically add attribute
    instance.foo = 42
    assert hasattr(instance, "foo")
    assert instance.foo == 42
    assert "foo" in dir(instance)

    # __dict__ should be accessible and replaceable
    assert "foo" in instance.__dict__
    instance.__dict__ = {"bar": True}
    assert not hasattr(instance, "foo")
    assert hasattr(instance, "bar")

    with pytest.raises(TypeError) as excinfo:
        instance.__dict__ = []
    assert str(excinfo.value) == "__dict__ must be set to a dictionary, not a 'list'"

293
    cstats = ConstructorStats.get(m.DynamicClass)
Dean Moldovan's avatar
Dean Moldovan committed
294
295
296
297
298
    assert cstats.alive() == 1
    del instance
    assert cstats.alive() == 0

    # Derived classes should work as well
299
    class PythonDerivedDynamicClass(m.DynamicClass):
Dean Moldovan's avatar
Dean Moldovan committed
300
301
        pass

302
    for cls in m.CppDerivedDynamicClass, PythonDerivedDynamicClass:
303
304
305
        derived = cls()
        derived.foobar = 100
        assert derived.foobar == 100
Dean Moldovan's avatar
Dean Moldovan committed
306

307
308
309
        assert cstats.alive() == 1
        del derived
        assert cstats.alive() == 0
Dean Moldovan's avatar
Dean Moldovan committed
310
311


312
313
# https://foss.heptapod.net/pypy/pypy/-/issues/2447
@pytest.mark.xfail("env.PYPY")
Dean Moldovan's avatar
Dean Moldovan committed
314
315
def test_cyclic_gc():
    # One object references itself
316
    instance = m.DynamicClass()
Dean Moldovan's avatar
Dean Moldovan committed
317
318
    instance.circular_reference = instance

319
    cstats = ConstructorStats.get(m.DynamicClass)
Dean Moldovan's avatar
Dean Moldovan committed
320
321
322
323
324
    assert cstats.alive() == 1
    del instance
    assert cstats.alive() == 0

    # Two object reference each other
325
326
    i1 = m.DynamicClass()
    i2 = m.DynamicClass()
Dean Moldovan's avatar
Dean Moldovan committed
327
328
329
330
331
332
    i1.cycle = i2
    i2.cycle = i1

    assert cstats.alive() == 2
    del i1, i2
    assert cstats.alive() == 0
333
334


335
def test_bad_arg_default(msg):
336
    from pybind11_tests import debug_enabled
337
338

    with pytest.raises(RuntimeError) as excinfo:
339
        m.bad_arg_def_named()
340
    assert msg(excinfo.value) == (
341
342
        "arg(): could not convert default argument 'a: UnregisteredType' in function "
        "'should_fail' into a Python object (type not registered yet?)"
343
344
        if debug_enabled
        else "arg(): could not convert default argument into a Python object (type not registered "
345
346
347
348
        "yet?). Compile in debug mode for more information."
    )

    with pytest.raises(RuntimeError) as excinfo:
349
        m.bad_arg_def_unnamed()
350
    assert msg(excinfo.value) == (
351
352
        "arg(): could not convert default argument 'UnregisteredType' in function "
        "'should_fail' into a Python object (type not registered yet?)"
353
354
        if debug_enabled
        else "arg(): could not convert default argument into a Python object (type not registered "
355
356
        "yet?). Compile in debug mode for more information."
    )
357
358


359
def test_accepts_none(msg):
360
361
362
363
364
365
366
367
368
369
370
    a = m.NoneTester()
    assert m.no_none1(a) == 42
    assert m.no_none2(a) == 42
    assert m.no_none3(a) == 42
    assert m.no_none4(a) == 42
    assert m.no_none5(a) == 42
    assert m.ok_none1(a) == 42
    assert m.ok_none2(a) == 42
    assert m.ok_none3(a) == 42
    assert m.ok_none4(a) == 42
    assert m.ok_none5(a) == 42
371
372

    with pytest.raises(TypeError) as excinfo:
373
        m.no_none1(None)
374
375
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
376
        m.no_none2(None)
377
378
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
379
        m.no_none3(None)
380
381
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
382
        m.no_none4(None)
383
384
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
385
        m.no_none5(None)
386
387
388
389
    assert "incompatible function arguments" in str(excinfo.value)

    # The first one still raises because you can't pass None as a lvalue reference arg:
    with pytest.raises(TypeError) as excinfo:
390
        assert m.ok_none1(None) == -1
391
392
393
    assert (
        msg(excinfo.value)
        == """
394
        ok_none1(): incompatible function arguments. The following argument types are supported:
395
            1. (arg0: m.methods_and_attributes.NoneTester) -> int
396
397
398

        Invoked with: None
    """
399
    )
400

401
    # The rest take the argument as pointer or holder, and accept None:
402
403
404
405
    assert m.ok_none2(None) == -1
    assert m.ok_none3(None) == -1
    assert m.ok_none4(None) == -1
    assert m.ok_none5(None) == -1
406

407
408
409
410
411
412
413
414
415
416
417
418
419
    with pytest.raises(TypeError) as excinfo:
        m.no_none_kwarg(None)
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
        m.no_none_kwarg(a=None)
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
        m.no_none_kwarg_kw_only(None)
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
        m.no_none_kwarg_kw_only(a=None)
    assert "incompatible function arguments" in str(excinfo.value)

420
421
422
423

def test_str_issue(msg):
    """#283: __str__ called on uninitialized instance when constructor arguments invalid"""

424
    assert str(m.StrIssue(3)) == "StrIssue[3]"
425
426

    with pytest.raises(TypeError) as excinfo:
427
        str(m.StrIssue("no", "such", "constructor"))
428
429
430
    assert (
        msg(excinfo.value)
        == """
431
        __init__(): incompatible constructor arguments. The following argument types are supported:
432
433
            1. m.methods_and_attributes.StrIssue(arg0: int)
            2. m.methods_and_attributes.StrIssue()
434
435
436

        Invoked with: 'no', 'such', 'constructor'
    """
437
    )
438
439
440


def test_unregistered_base_implementations():
441
    a = m.RegisteredDerived()
442
443
444
445
446
447
448
449
450
451
452
453
454
455
    a.do_nothing()
    assert a.rw_value == 42
    assert a.ro_value == 1.25
    a.rw_value += 5
    assert a.sum() == 48.25
    a.increase_value()
    assert a.rw_value == 48
    assert a.ro_value == 1.5
    assert a.sum() == 49.5
    assert a.rw_value_prop == 48
    a.rw_value_prop += 1
    assert a.rw_value_prop == 49
    a.increase_value()
    assert a.ro_value_prop == 1.75
456
457


458
459
460
461
462
463
464
465
466
def test_ref_qualified():
    """Tests that explicit lvalue ref-qualified methods can be called just like their
    non ref-qualified counterparts."""

    r = m.RefQualified()
    assert r.value == 0
    r.refQualified(17)
    assert r.value == 17
    assert r.constRefQualified(23) == 40
467
468
469


def test_overload_ordering():
470
    "Check to see if the normal overload order (first defined) and prepend overload order works"
471
472
473
474
475
476
477
    assert m.overload_order("string") == 1
    assert m.overload_order(0) == 4

    # Different for Python 2 vs. 3
    uni_name = type(u"").__name__

    assert "1. overload_order(arg0: int) -> int" in m.overload_order.__doc__
478
479
480
481
482
483
484
485
    assert (
        "2. overload_order(arg0: {}) -> int".format(uni_name)
        in m.overload_order.__doc__
    )
    assert (
        "3. overload_order(arg0: {}) -> int".format(uni_name)
        in m.overload_order.__doc__
    )
486
487
488
489
490
491
492
493
494
    assert "4. overload_order(arg0: int) -> int" in m.overload_order.__doc__

    with pytest.raises(TypeError) as err:
        m.overload_order(1.1)

    assert "1. (arg0: int) -> int" in str(err.value)
    assert "2. (arg0: {}) -> int".format(uni_name) in str(err.value)
    assert "3. (arg0: {}) -> int".format(uni_name) in str(err.value)
    assert "4. (arg0: int) -> int" in str(err.value)