test_methods_and_attributes.py 17.2 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
178
179
180
181
182
183
184
185
186
    # Only static attributes can be deleted
    del m.TestPropertiesOverride.def_readonly_static
    assert (
        hasattr(m.TestPropertiesOverride, "def_readonly_static")
        and m.TestPropertiesOverride.def_readonly_static
        is m.TestProperties.def_readonly_static
    )
    assert "def_readonly_static" not in m.TestPropertiesOverride.__dict__
    properties_override = m.TestPropertiesOverride()
    with pytest.raises(AttributeError) as excinfo:
        del properties_override.def_readonly
    assert "can't delete attribute" in str(excinfo.value)

187
188
189
190

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

191
192
193
    instance = m.TestProperties()
    assert m.TestProperties.static_cls is m.TestProperties
    assert instance.static_cls is m.TestProperties
194
195

    def check_self(self):
196
        assert self is m.TestProperties
197

198
    m.TestProperties.static_cls = check_self
199
200
    instance.static_cls = check_self

201

202
203
204
def test_metaclass_override():
    """Overriding pybind11's default metaclass changes the behavior of `static_property`"""

205
206
    assert type(m.ExampleMandA).__name__ == "pybind11_type"
    assert type(m.MetaclassOverride).__name__ == "type"
207

208
    assert m.MetaclassOverride.readonly == 1
209
210
211
212
    assert (
        type(m.MetaclassOverride.__dict__["readonly"]).__name__
        == "pybind11_static_property"
    )
213
214

    # Regular `type` replaces the property instead of calling `__set__()`
215
216
217
    m.MetaclassOverride.readonly = 2
    assert m.MetaclassOverride.readonly == 2
    assert isinstance(m.MetaclassOverride.__dict__["readonly"], int)
218
219


220
221
222
223
def test_no_mixed_overloads():
    from pybind11_tests import debug_enabled

    with pytest.raises(RuntimeError) as excinfo:
224
        m.ExampleMandA.add_mixed_overloads1()
225
226
227
228
229
230
231
232
    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"
    )
233
234

    with pytest.raises(RuntimeError) as excinfo:
235
        m.ExampleMandA.add_mixed_overloads2()
236
237
238
239
240
241
242
243
244
    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"
    )
245
246


247
248
249
@pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"])
def test_property_return_value_policies(access):
    if not access.startswith("static"):
250
        obj = m.TestPropRVP()
251
    else:
252
        obj = m.TestPropRVP
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272

    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
273
    `reference(_internal)` to `move`. The following would not work otherwise."""
274

275
    instance = m.TestPropRVP()
276
277
    o = instance.rvalue
    assert o.value == 1
Wenzel Jakob's avatar
Wenzel Jakob committed
278

279
280
    os = m.TestPropRVP.static_rvalue
    assert os.value == 1
281
282


283
284
# https://foss.heptapod.net/pypy/pypy/-/issues/2447
@pytest.mark.xfail("env.PYPY")
Dean Moldovan's avatar
Dean Moldovan committed
285
def test_dynamic_attributes():
286
    instance = m.DynamicClass()
Dean Moldovan's avatar
Dean Moldovan committed
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
    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'"

306
    cstats = ConstructorStats.get(m.DynamicClass)
Dean Moldovan's avatar
Dean Moldovan committed
307
308
309
310
311
    assert cstats.alive() == 1
    del instance
    assert cstats.alive() == 0

    # Derived classes should work as well
312
    class PythonDerivedDynamicClass(m.DynamicClass):
Dean Moldovan's avatar
Dean Moldovan committed
313
314
        pass

315
    for cls in m.CppDerivedDynamicClass, PythonDerivedDynamicClass:
316
317
318
        derived = cls()
        derived.foobar = 100
        assert derived.foobar == 100
Dean Moldovan's avatar
Dean Moldovan committed
319

320
321
322
        assert cstats.alive() == 1
        del derived
        assert cstats.alive() == 0
Dean Moldovan's avatar
Dean Moldovan committed
323
324


325
326
# https://foss.heptapod.net/pypy/pypy/-/issues/2447
@pytest.mark.xfail("env.PYPY")
Dean Moldovan's avatar
Dean Moldovan committed
327
328
def test_cyclic_gc():
    # One object references itself
329
    instance = m.DynamicClass()
Dean Moldovan's avatar
Dean Moldovan committed
330
331
    instance.circular_reference = instance

332
    cstats = ConstructorStats.get(m.DynamicClass)
Dean Moldovan's avatar
Dean Moldovan committed
333
334
335
336
337
    assert cstats.alive() == 1
    del instance
    assert cstats.alive() == 0

    # Two object reference each other
338
339
    i1 = m.DynamicClass()
    i2 = m.DynamicClass()
Dean Moldovan's avatar
Dean Moldovan committed
340
341
342
343
344
345
    i1.cycle = i2
    i2.cycle = i1

    assert cstats.alive() == 2
    del i1, i2
    assert cstats.alive() == 0
346
347


348
def test_bad_arg_default(msg):
349
    from pybind11_tests import debug_enabled
350
351

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

    with pytest.raises(RuntimeError) as excinfo:
362
        m.bad_arg_def_unnamed()
363
    assert msg(excinfo.value) == (
364
365
        "arg(): could not convert default argument 'UnregisteredType' in function "
        "'should_fail' into a Python object (type not registered yet?)"
366
367
        if debug_enabled
        else "arg(): could not convert default argument into a Python object (type not registered "
368
369
        "yet?). Compile in debug mode for more information."
    )
370
371


372
def test_accepts_none(msg):
373
374
375
376
377
378
379
380
381
382
383
    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
384
385

    with pytest.raises(TypeError) as excinfo:
386
        m.no_none1(None)
387
388
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
389
        m.no_none2(None)
390
391
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
392
        m.no_none3(None)
393
394
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
395
        m.no_none4(None)
396
397
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
398
        m.no_none5(None)
399
400
401
402
    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:
403
        assert m.ok_none1(None) == -1
404
405
406
    assert (
        msg(excinfo.value)
        == """
407
        ok_none1(): incompatible function arguments. The following argument types are supported:
408
            1. (arg0: m.methods_and_attributes.NoneTester) -> int
409
410
411

        Invoked with: None
    """
412
    )
413

414
    # The rest take the argument as pointer or holder, and accept None:
415
416
417
418
    assert m.ok_none2(None) == -1
    assert m.ok_none3(None) == -1
    assert m.ok_none4(None) == -1
    assert m.ok_none5(None) == -1
419

420
421
422
423
424
425
426
427
428
429
430
431
432
    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)

433

434
435
436
437
438
439
440
441
442
443
444
def test_casts_none(msg):
    """#2778: implicit casting from None to object (not pointer)"""
    a = m.NoneCastTester()
    assert m.ok_obj_or_none(a) == -1
    a = m.NoneCastTester(4)
    assert m.ok_obj_or_none(a) == 4
    a = m.NoneCastTester(None)
    assert m.ok_obj_or_none(a) == -1
    assert m.ok_obj_or_none(None) == -1


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

448
    assert str(m.StrIssue(3)) == "StrIssue[3]"
449
450

    with pytest.raises(TypeError) as excinfo:
451
        str(m.StrIssue("no", "such", "constructor"))
452
453
454
    assert (
        msg(excinfo.value)
        == """
455
        __init__(): incompatible constructor arguments. The following argument types are supported:
456
457
            1. m.methods_and_attributes.StrIssue(arg0: int)
            2. m.methods_and_attributes.StrIssue()
458
459
460

        Invoked with: 'no', 'such', 'constructor'
    """
461
    )
462
463
464


def test_unregistered_base_implementations():
465
    a = m.RegisteredDerived()
466
467
468
469
470
471
472
473
474
475
476
477
478
479
    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
480
481


482
483
484
485
486
487
488
489
490
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
491
492
493


def test_overload_ordering():
494
    "Check to see if the normal overload order (first defined) and prepend overload order works"
495
496
497
498
499
500
501
    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__
502
503
504
505
506
507
508
509
    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__
    )
510
511
512
513
514
515
516
517
518
    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)