Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-12 00:23:53 +00:00
Code Issues Packages Projects Releases Wiki Activity
93cc4bd6d7
pybind11/tests/test_kwargs_and_defaults.py

107 lines
4.2 KiB
Python
Raw Normal View History

Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
import pytest
Remove superseded handle::operator() overloads The variadic handle::operator() offers the same functionality as well as mixed positional, keyword, * and ** arguments. The tests are also superseded by the ones in `test_callbacks`.
2016-09-03 15:25:40 +00:00
from pybind11_tests import (kw_func0, kw_func1, kw_func2, kw_func3, kw_func4, args_function,
args_kwargs_function, kw_func_udl, kw_func_udl_z, KWClass)
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
def test_function_signatures(doc):
Simplify tests by replacing output capture with asserts where possible The C++ part of the test code is modified to achieve this. As a result, this kind of test: ```python with capture: kw_func1(5, y=10) assert capture == "kw_func(x=5, y=10)" ``` can be replaced with a simple: `assert kw_func1(5, y=10) == "x=5, y=10"`
2016-08-12 20:28:31 +00:00
assert doc(kw_func0) == "kw_func0(arg0: int, arg1: int) -> str"
assert doc(kw_func1) == "kw_func1(x: int, y: int) -> str"
assert doc(kw_func2) == "kw_func2(x: int=100, y: int=200) -> str"
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert doc(kw_func3) == "kw_func3(data: str='Hello world!') -> None"
Simplify tests by replacing output capture with asserts where possible The C++ part of the test code is modified to achieve this. As a result, this kind of test: ```python with capture: kw_func1(5, y=10) assert capture == "kw_func(x=5, y=10)" ``` can be replaced with a simple: `assert kw_func1(5, y=10) == "x=5, y=10"`
2016-08-12 20:28:31 +00:00
assert doc(kw_func4) == "kw_func4(myList: List[int]=[13, 17]) -> str"
assert doc(kw_func_udl) == "kw_func_udl(x: int, y: int=300) -> str"
assert doc(kw_func_udl_z) == "kw_func_udl_z(x: int, y: int=0) -> str"
Simplify more tests by replacing capture with assert
2016-08-19 11:45:36 +00:00
assert doc(args_function) == "args_function(*args) -> tuple"
assert doc(args_kwargs_function) == "args_kwargs_function(*args, **kwargs) -> tuple"
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert doc(KWClass.foo0) == "foo0(self: m.KWClass, arg0: int, arg1: float) -> None"
assert doc(KWClass.foo1) == "foo1(self: m.KWClass, x: int, y: float) -> None"
Simplify tests by replacing output capture with asserts where possible The C++ part of the test code is modified to achieve this. As a result, this kind of test: ```python with capture: kw_func1(5, y=10) assert capture == "kw_func(x=5, y=10)" ``` can be replaced with a simple: `assert kw_func1(5, y=10) == "x=5, y=10"`
2016-08-12 20:28:31 +00:00
def test_named_arguments(msg):
assert kw_func0(5, 10) == "x=5, y=10"
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Simplify tests by replacing output capture with asserts where possible The C++ part of the test code is modified to achieve this. As a result, this kind of test: ```python with capture: kw_func1(5, y=10) assert capture == "kw_func(x=5, y=10)" ``` can be replaced with a simple: `assert kw_func1(5, y=10) == "x=5, y=10"`
2016-08-12 20:28:31 +00:00
assert kw_func1(5, 10) == "x=5, y=10"
assert kw_func1(5, y=10) == "x=5, y=10"
assert kw_func1(y=10, x=5) == "x=5, y=10"
assert kw_func2() == "x=100, y=200"
assert kw_func2(5) == "x=5, y=200"
assert kw_func2(x=5) == "x=5, y=200"
assert kw_func2(y=10) == "x=100, y=10"
assert kw_func2(5, 10) == "x=5, y=10"
assert kw_func2(x=5, y=10) == "x=5, y=10"
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
with pytest.raises(TypeError) as excinfo:
# noinspection PyArgumentList
kw_func2(x=5, y=10, z=12)
assert msg(excinfo.value) == """
nicer error message for invalid function arguments
2016-09-12 02:44:37 +00:00
kw_func2(): incompatible function arguments. The following argument types are supported:
Simplify tests by replacing output capture with asserts where possible The C++ part of the test code is modified to achieve this. As a result, this kind of test: ```python with capture: kw_func1(5, y=10) assert capture == "kw_func(x=5, y=10)" ``` can be replaced with a simple: `assert kw_func1(5, y=10) == "x=5, y=10"`
2016-08-12 20:28:31 +00:00
1. (x: int=100, y: int=200) -> str
nicer error message for invalid function arguments
2016-09-12 02:44:37 +00:00
Invoked with:
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
"""
Simplify tests by replacing output capture with asserts where possible The C++ part of the test code is modified to achieve this. As a result, this kind of test: ```python with capture: kw_func1(5, y=10) assert capture == "kw_func(x=5, y=10)" ``` can be replaced with a simple: `assert kw_func1(5, y=10) == "x=5, y=10"`
2016-08-12 20:28:31 +00:00
assert kw_func4() == "{13 17}"
assert kw_func4(myList=[1, 2, 3]) == "{1 2 3}"
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Simplify tests by replacing output capture with asserts where possible The C++ part of the test code is modified to achieve this. As a result, this kind of test: ```python with capture: kw_func1(5, y=10) assert capture == "kw_func(x=5, y=10)" ``` can be replaced with a simple: `assert kw_func1(5, y=10) == "x=5, y=10"`
2016-08-12 20:28:31 +00:00
assert kw_func_udl(x=5, y=10) == "x=5, y=10"
assert kw_func_udl_z(x=5) == "x=5, y=0"
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Simplify more tests by replacing capture with assert
2016-08-19 11:45:36 +00:00
def test_arg_and_kwargs():
args = 'arg1_value', 'arg2_value', 3
assert args_function(*args) == args
args = 'a1', 'a2'
kwargs = dict(arg3='a3', arg4=4)
assert args_kwargs_function(*args, **kwargs) == (args, kwargs)
Add support for positional args with args/kwargs This commit rewrites the function dispatcher code to support mixing regular arguments with py::args/py::kwargs arguments. It also simplifies the argument loader noticeably as it no longer has to worry about args/kwargs: all of that is now sorted out in the dispatcher, which now simply appends a tuple/dict if the function takes py::args/py::kwargs, then passes all the arguments in a vector. When the argument loader hit a py::args or py::kwargs, it doesn't do anything special: it just calls the appropriate type_caster just like it does for any other argument (thus removing the previous special cases for args/kwargs). Switching to passing arguments in a single std::vector instead of a pair of tuples also makes things simpler, both in the dispatch and the argument_loader: since this argument list is strictly pybind-internal (i.e. it never goes to Python) we have no particular reason to use a Python tuple here. Some (intentional) restrictions: - you may not bind a function that has args/kwargs somewhere other than the end (this somewhat matches Python, and keeps the dispatch code a little cleaner by being able to not worry about where to inject the args/kwargs in the argument list). - If you specify an argument both positionally and via a keyword argument, you get a TypeError alerting you to this (as you do in Python).
2017-01-22 04:42:14 +00:00
def test_mixed_args_and_kwargs(msg):
from pybind11_tests import (mixed_plus_args, mixed_plus_kwargs, mixed_plus_args_kwargs,
mixed_plus_args_kwargs_defaults)
mpa = mixed_plus_args
mpk = mixed_plus_kwargs
mpak = mixed_plus_args_kwargs
mpakd = mixed_plus_args_kwargs_defaults
assert mpa(1, 2.5, 4, 99.5, None) == (1, 2.5, (4, 99.5, None))
assert mpa(1, 2.5) == (1, 2.5, ())
with pytest.raises(TypeError) as excinfo:
assert mpa(1)
assert msg(excinfo.value) == """
mixed_plus_args(): incompatible function arguments. The following argument types are supported:
1. (arg0: int, arg1: float, *args) -> tuple
Invoked with: 1
""" # noqa: E501
with pytest.raises(TypeError) as excinfo:
assert mpa()
assert msg(excinfo.value) == """
mixed_plus_args(): incompatible function arguments. The following argument types are supported:
1. (arg0: int, arg1: float, *args) -> tuple
Invoked with:
""" # noqa: E501
assert mpk(-2, 3.5, pi=3.14159, e=2.71828) == (-2, 3.5, {'e': 2.71828, 'pi': 3.14159})
assert mpak(7, 7.7, 7.77, 7.777, 7.7777, minusseven=-7) == (
7, 7.7, (7.77, 7.777, 7.7777), {'minusseven': -7})
assert mpakd() == (1, 3.14159, (), {})
assert mpakd(3) == (3, 3.14159, (), {})
assert mpakd(j=2.71828) == (1, 2.71828, (), {})
assert mpakd(k=42) == (1, 3.14159, (), {'k': 42})
assert mpakd(1, 1, 2, 3, 5, 8, then=13, followedby=21) == (
1, 1, (2, 3, 5, 8), {'then': 13, 'followedby': 21})
# Arguments specified both positionally and via kwargs is an error:
with pytest.raises(TypeError) as excinfo:
assert mpakd(1, i=1)
assert msg(excinfo.value) == """
mixed_plus_args_kwargs_defaults(): got multiple values for argument 'i'
"""
with pytest.raises(TypeError) as excinfo:
assert mpakd(1, 2, j=1)
assert msg(excinfo.value) == """
mixed_plus_args_kwargs_defaults(): got multiple values for argument 'j'
"""
Reference in New Issue Copy Permalink