xcoll 0.5.12__py3-none-any.whl → 0.6.1__py3-none-any.whl

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_kwargs_and_defaults.py

@@ -1,284 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import kwargs_and_defaults as m
-
-
-def test_function_signatures(doc):
-    assert doc(m.kw_func0) == "kw_func0(arg0: int, arg1: int) -> str"
-    assert doc(m.kw_func1) == "kw_func1(x: int, y: int) -> str"
-    assert doc(m.kw_func2) == "kw_func2(x: int = 100, y: int = 200) -> str"
-    assert doc(m.kw_func3) == "kw_func3(data: str = 'Hello world!') -> None"
-    assert doc(m.kw_func4) == "kw_func4(myList: List[int] = [13, 17]) -> str"
-    assert doc(m.kw_func_udl) == "kw_func_udl(x: int, y: int = 300) -> str"
-    assert doc(m.kw_func_udl_z) == "kw_func_udl_z(x: int, y: int = 0) -> str"
-    assert doc(m.args_function) == "args_function(*args) -> tuple"
-    assert (
-        doc(m.args_kwargs_function) == "args_kwargs_function(*args, **kwargs) -> tuple"
-    )
-    assert (
-        doc(m.KWClass.foo0)
-        == "foo0(self: m.kwargs_and_defaults.KWClass, arg0: int, arg1: float) -> None"
-    )
-    assert (
-        doc(m.KWClass.foo1)
-        == "foo1(self: m.kwargs_and_defaults.KWClass, x: int, y: float) -> None"
-    )
-
-
-def test_named_arguments(msg):
-    assert m.kw_func0(5, 10) == "x=5, y=10"
-
-    assert m.kw_func1(5, 10) == "x=5, y=10"
-    assert m.kw_func1(5, y=10) == "x=5, y=10"
-    assert m.kw_func1(y=10, x=5) == "x=5, y=10"
-
-    assert m.kw_func2() == "x=100, y=200"
-    assert m.kw_func2(5) == "x=5, y=200"
-    assert m.kw_func2(x=5) == "x=5, y=200"
-    assert m.kw_func2(y=10) == "x=100, y=10"
-    assert m.kw_func2(5, 10) == "x=5, y=10"
-    assert m.kw_func2(x=5, y=10) == "x=5, y=10"
-
-    with pytest.raises(TypeError) as excinfo:
-        # noinspection PyArgumentList
-        m.kw_func2(x=5, y=10, z=12)
-    assert excinfo.match(
-        r"(?s)^kw_func2\(\): incompatible.*Invoked with: kwargs: ((x=5|y=10|z=12)(, |$))"
-        + "{3}$"
-    )
-
-    assert m.kw_func4() == "{13 17}"
-    assert m.kw_func4(myList=[1, 2, 3]) == "{1 2 3}"
-
-    assert m.kw_func_udl(x=5, y=10) == "x=5, y=10"
-    assert m.kw_func_udl_z(x=5) == "x=5, y=0"
-
-
-def test_arg_and_kwargs():
-    args = "arg1_value", "arg2_value", 3
-    assert m.args_function(*args) == args
-
-    args = "a1", "a2"
-    kwargs = dict(arg3="a3", arg4=4)
-    assert m.args_kwargs_function(*args, **kwargs) == (args, kwargs)
-
-
-def test_mixed_args_and_kwargs(msg):
-    mpa = m.mixed_plus_args
-    mpk = m.mixed_plus_kwargs
-    mpak = m.mixed_plus_args_kwargs
-    mpakd = m.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 line too long
-    )
-    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 line too long
-    )
-
-    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 should fail:
-    with pytest.raises(TypeError) as excinfo:
-        assert mpakd(1, i=1)
-    assert (
-        msg(excinfo.value)
-        == """
-        mixed_plus_args_kwargs_defaults(): incompatible function arguments. The following argument types are supported:
-            1. (i: int = 1, j: float = 3.14159, *args, **kwargs) -> tuple
-
-        Invoked with: 1; kwargs: i=1
-    """  # noqa: E501 line too long
-    )
-    with pytest.raises(TypeError) as excinfo:
-        assert mpakd(1, 2, j=1)
-    assert (
-        msg(excinfo.value)
-        == """
-        mixed_plus_args_kwargs_defaults(): incompatible function arguments. The following argument types are supported:
-            1. (i: int = 1, j: float = 3.14159, *args, **kwargs) -> tuple
-
-        Invoked with: 1, 2; kwargs: j=1
-    """  # noqa: E501 line too long
-    )
-
-
-def test_keyword_only_args(msg):
-    assert m.kw_only_all(i=1, j=2) == (1, 2)
-    assert m.kw_only_all(j=1, i=2) == (2, 1)
-
-    with pytest.raises(TypeError) as excinfo:
-        assert m.kw_only_all(i=1) == (1,)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        assert m.kw_only_all(1, 2) == (1, 2)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    assert m.kw_only_some(1, k=3, j=2) == (1, 2, 3)
-
-    assert m.kw_only_with_defaults(z=8) == (3, 4, 5, 8)
-    assert m.kw_only_with_defaults(2, z=8) == (2, 4, 5, 8)
-    assert m.kw_only_with_defaults(2, j=7, k=8, z=9) == (2, 7, 8, 9)
-    assert m.kw_only_with_defaults(2, 7, z=9, k=8) == (2, 7, 8, 9)
-
-    assert m.kw_only_mixed(1, j=2) == (1, 2)
-    assert m.kw_only_mixed(j=2, i=3) == (3, 2)
-    assert m.kw_only_mixed(i=2, j=3) == (2, 3)
-
-    assert m.kw_only_plus_more(4, 5, k=6, extra=7) == (4, 5, 6, {"extra": 7})
-    assert m.kw_only_plus_more(3, k=5, j=4, extra=6) == (3, 4, 5, {"extra": 6})
-    assert m.kw_only_plus_more(2, k=3, extra=4) == (2, -1, 3, {"extra": 4})
-
-    with pytest.raises(TypeError) as excinfo:
-        assert m.kw_only_mixed(i=1) == (1,)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.register_invalid_kw_only(m)
-    assert (
-        msg(excinfo.value)
-        == """
-        arg(): cannot specify an unnamed argument after an kw_only() annotation
-    """
-    )
-
-
-def test_positional_only_args(msg):
-    assert m.pos_only_all(1, 2) == (1, 2)
-    assert m.pos_only_all(2, 1) == (2, 1)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.pos_only_all(i=1, j=2)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    assert m.pos_only_mix(1, 2) == (1, 2)
-    assert m.pos_only_mix(2, j=1) == (2, 1)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.pos_only_mix(i=1, j=2)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    assert m.pos_kw_only_mix(1, 2, k=3) == (1, 2, 3)
-    assert m.pos_kw_only_mix(1, j=2, k=3) == (1, 2, 3)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.pos_kw_only_mix(i=1, j=2, k=3)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.pos_kw_only_mix(1, 2, 3)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.pos_only_def_mix()
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    assert m.pos_only_def_mix(1) == (1, 2, 3)
-    assert m.pos_only_def_mix(1, 4) == (1, 4, 3)
-    assert m.pos_only_def_mix(1, 4, 7) == (1, 4, 7)
-    assert m.pos_only_def_mix(1, 4, k=7) == (1, 4, 7)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.pos_only_def_mix(1, j=4)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test_signatures():
-    assert "kw_only_all(*, i: int, j: int) -> tuple\n" == m.kw_only_all.__doc__
-    assert "kw_only_mixed(i: int, *, j: int) -> tuple\n" == m.kw_only_mixed.__doc__
-    assert "pos_only_all(i: int, j: int, /) -> tuple\n" == m.pos_only_all.__doc__
-    assert "pos_only_mix(i: int, /, j: int) -> tuple\n" == m.pos_only_mix.__doc__
-    assert (
-        "pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple\n"
-        == m.pos_kw_only_mix.__doc__
-    )
-
-
-@pytest.mark.xfail("env.PYPY and env.PY2", reason="PyPy2 doesn't double count")
-def test_args_refcount():
-    """Issue/PR #1216 - py::args elements get double-inc_ref()ed when combined with regular
-    arguments"""
-    refcount = m.arg_refcount_h
-
-    myval = 54321
-    expected = refcount(myval)
-    assert m.arg_refcount_h(myval) == expected
-    assert m.arg_refcount_o(myval) == expected + 1
-    assert m.arg_refcount_h(myval) == expected
-    assert refcount(myval) == expected
-
-    assert m.mixed_plus_args(1, 2.0, "a", myval) == (1, 2.0, ("a", myval))
-    assert refcount(myval) == expected
-
-    assert m.mixed_plus_kwargs(3, 4.0, a=1, b=myval) == (3, 4.0, {"a": 1, "b": myval})
-    assert refcount(myval) == expected
-
-    assert m.args_function(-1, myval) == (-1, myval)
-    assert refcount(myval) == expected
-
-    assert m.mixed_plus_args_kwargs(5, 6.0, myval, a=myval) == (
-        5,
-        6.0,
-        (myval,),
-        {"a": myval},
-    )
-    assert refcount(myval) == expected
-
-    assert m.args_kwargs_function(7, 8, myval, a=1, b=myval) == (
-        (7, 8, myval),
-        {"a": 1, "b": myval},
-    )
-    assert refcount(myval) == expected
-
-    exp3 = refcount(myval, myval, myval)
-    assert m.args_refcount(myval, myval, myval) == (exp3, exp3, exp3)
-    assert refcount(myval) == expected
-
-    # This function takes the first arg as a `py::object` and the rest as a `py::args`.  Unlike the
-    # previous case, when we have both positional and `py::args` we need to construct a new tuple
-    # for the `py::args`; in the previous case, we could simply inc_ref and pass on Python's input
-    # tuple without having to inc_ref the individual elements, but here we can't, hence the extra
-    # refs.
-    assert m.mixed_args_refcount(myval, myval, myval) == (exp3 + 3, exp3 + 3, exp3 + 3)
-
-    assert m.class_default_argument() == "<class 'decimal.Decimal'>"

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_local_bindings.cpp

@@ -1,107 +0,0 @@
-/*
-    tests/test_local_bindings.cpp -- tests the py::module_local class feature which makes a class
-                                     binding local to the module in which it is defined.
-
-    Copyright (c) 2017 Jason Rhinelander <jason@imaginary.ca>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "local_bindings.h"
-
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
-
-#include <numeric>
-#include <utility>
-
-TEST_SUBMODULE(local_bindings, m) {
-    // test_load_external
-    m.def("load_external1", [](ExternalType1 &e) { return e.i; });
-    m.def("load_external2", [](ExternalType2 &e) { return e.i; });
-
-    // test_local_bindings
-    // Register a class with py::module_local:
-    bind_local<LocalType, -1>(m, "LocalType", py::module_local())
-        .def("get3", [](LocalType &t) { return t.i + 3; })
-        ;
-
-    m.def("local_value", [](LocalType &l) { return l.i; });
-
-    // test_nonlocal_failure
-    // The main pybind11 test module is loaded first, so this registration will succeed (the second
-    // one, in pybind11_cross_module_tests.cpp, is designed to fail):
-    bind_local<NonLocalType, 0>(m, "NonLocalType")
-        .def(py::init<int>())
-        .def("get", [](LocalType &i) { return i.i; })
-        ;
-
-    // test_duplicate_local
-    // py::module_local declarations should be visible across compilation units that get linked together;
-    // this tries to register a duplicate local.  It depends on a definition in test_class.cpp and
-    // should raise a runtime error from the duplicate definition attempt.  If test_class isn't
-    // available it *also* throws a runtime error (with "test_class not enabled" as value).
-    m.def("register_local_external", [m]() {
-        auto main = py::module_::import("pybind11_tests");
-        if (py::hasattr(main, "class_")) {
-            bind_local<LocalExternal, 7>(m, "LocalExternal", py::module_local());
-        }
-        else throw std::runtime_error("test_class not enabled");
-    });
-
-    // test_stl_bind_local
-    // stl_bind.h binders defaults to py::module_local if the types are local or converting:
-    py::bind_vector<LocalVec>(m, "LocalVec");
-    py::bind_map<LocalMap>(m, "LocalMap");
-    // and global if the type (or one of the types, for the map) is global:
-    py::bind_vector<NonLocalVec>(m, "NonLocalVec");
-    py::bind_map<NonLocalMap>(m, "NonLocalMap");
-
-    // test_stl_bind_global
-    // They can, however, be overridden to global using `py::module_local(false)`:
-    bind_local<NonLocal2, 10>(m, "NonLocal2");
-    py::bind_vector<LocalVec2>(m, "LocalVec2", py::module_local());
-    py::bind_map<NonLocalMap2>(m, "NonLocalMap2", py::module_local(false));
-
-    // test_mixed_local_global
-    // We try this both with the global type registered first and vice versa (the order shouldn't
-    // matter).
-    m.def("register_mixed_global", [m]() {
-        bind_local<MixedGlobalLocal, 100>(m, "MixedGlobalLocal", py::module_local(false));
-    });
-    m.def("register_mixed_local", [m]() {
-        bind_local<MixedLocalGlobal, 1000>(m, "MixedLocalGlobal", py::module_local());
-    });
-    m.def("get_mixed_gl", [](int i) { return MixedGlobalLocal(i); });
-    m.def("get_mixed_lg", [](int i) { return MixedLocalGlobal(i); });
-
-    // test_internal_locals_differ
-    m.def("local_cpp_types_addr", []() { return (uintptr_t) &py::detail::get_local_internals().registered_types_cpp; });
-
-    // test_stl_caster_vs_stl_bind
-    m.def("load_vector_via_caster", [](std::vector<int> v) {
-        return std::accumulate(v.begin(), v.end(), 0);
-    });
-
-    // test_cross_module_calls
-    m.def("return_self", [](LocalVec *v) { return v; });
-    m.def("return_copy", [](const LocalVec &v) { return LocalVec(v); });
-
-    class Cat : public pets::Pet {
-    public:
-        explicit Cat(std::string name) : Pet(std::move(name)) {}
-    };
-    py::class_<pets::Pet>(m, "Pet", py::module_local())
-        .def("get_name", &pets::Pet::name);
-    // Binding for local extending class:
-    py::class_<Cat, pets::Pet>(m, "Cat")
-        .def(py::init<std::string>());
-    m.def("pet_name", [](pets::Pet &p) { return p.name(); });
-
-    py::class_<MixGL>(m, "MixGL").def(py::init<int>());
-    m.def("get_gl_value", [](MixGL &o) { return o.i + 10; });
-
-    py::class_<MixGL2>(m, "MixGL2").def(py::init<int>());
-}

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_local_bindings.py

@@ -1,257 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import local_bindings as m
-
-
-def test_load_external():
-    """Load a `py::module_local` type that's only registered in an external module"""
-    import pybind11_cross_module_tests as cm
-
-    assert m.load_external1(cm.ExternalType1(11)) == 11
-    assert m.load_external2(cm.ExternalType2(22)) == 22
-
-    with pytest.raises(TypeError) as excinfo:
-        assert m.load_external2(cm.ExternalType1(21)) == 21
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        assert m.load_external1(cm.ExternalType2(12)) == 12
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test_local_bindings():
-    """Tests that duplicate `py::module_local` class bindings work across modules"""
-
-    # Make sure we can load the second module with the conflicting (but local) definition:
-    import pybind11_cross_module_tests as cm
-
-    i1 = m.LocalType(5)
-    assert i1.get() == 4
-    assert i1.get3() == 8
-
-    i2 = cm.LocalType(10)
-    assert i2.get() == 11
-    assert i2.get2() == 12
-
-    assert not hasattr(i1, "get2")
-    assert not hasattr(i2, "get3")
-
-    # Loading within the local module
-    assert m.local_value(i1) == 5
-    assert cm.local_value(i2) == 10
-
-    # Cross-module loading works as well (on failure, the type loader looks for
-    # external module-local converters):
-    assert m.local_value(i2) == 10
-    assert cm.local_value(i1) == 5
-
-
-def test_nonlocal_failure():
-    """Tests that attempting to register a non-local type in multiple modules fails"""
-    import pybind11_cross_module_tests as cm
-
-    with pytest.raises(RuntimeError) as excinfo:
-        cm.register_nonlocal()
-    assert (
-        str(excinfo.value) == 'generic_type: type "NonLocalType" is already registered!'
-    )
-
-
-def test_duplicate_local():
-    """Tests expected failure when registering a class twice with py::local in the same module"""
-    with pytest.raises(RuntimeError) as excinfo:
-        m.register_local_external()
-    import pybind11_tests
-
-    assert str(excinfo.value) == (
-        'generic_type: type "LocalExternal" is already registered!'
-        if hasattr(pybind11_tests, "class_")
-        else "test_class not enabled"
-    )
-
-
-def test_stl_bind_local():
-    import pybind11_cross_module_tests as cm
-
-    v1, v2 = m.LocalVec(), cm.LocalVec()
-    v1.append(m.LocalType(1))
-    v1.append(m.LocalType(2))
-    v2.append(cm.LocalType(1))
-    v2.append(cm.LocalType(2))
-
-    # Cross module value loading:
-    v1.append(cm.LocalType(3))
-    v2.append(m.LocalType(3))
-
-    assert [i.get() for i in v1] == [0, 1, 2]
-    assert [i.get() for i in v2] == [2, 3, 4]
-
-    v3, v4 = m.NonLocalVec(), cm.NonLocalVec2()
-    v3.append(m.NonLocalType(1))
-    v3.append(m.NonLocalType(2))
-    v4.append(m.NonLocal2(3))
-    v4.append(m.NonLocal2(4))
-
-    assert [i.get() for i in v3] == [1, 2]
-    assert [i.get() for i in v4] == [13, 14]
-
-    d1, d2 = m.LocalMap(), cm.LocalMap()
-    d1["a"] = v1[0]
-    d1["b"] = v1[1]
-    d2["c"] = v2[0]
-    d2["d"] = v2[1]
-    assert {i: d1[i].get() for i in d1} == {"a": 0, "b": 1}
-    assert {i: d2[i].get() for i in d2} == {"c": 2, "d": 3}
-
-
-def test_stl_bind_global():
-    import pybind11_cross_module_tests as cm
-
-    with pytest.raises(RuntimeError) as excinfo:
-        cm.register_nonlocal_map()
-    assert (
-        str(excinfo.value) == 'generic_type: type "NonLocalMap" is already registered!'
-    )
-
-    with pytest.raises(RuntimeError) as excinfo:
-        cm.register_nonlocal_vec()
-    assert (
-        str(excinfo.value) == 'generic_type: type "NonLocalVec" is already registered!'
-    )
-
-    with pytest.raises(RuntimeError) as excinfo:
-        cm.register_nonlocal_map2()
-    assert (
-        str(excinfo.value) == 'generic_type: type "NonLocalMap2" is already registered!'
-    )
-
-
-def test_mixed_local_global():
-    """Local types take precedence over globally registered types: a module with a `module_local`
-    type can be registered even if the type is already registered globally.  With the module,
-    casting will go to the local type; outside the module casting goes to the global type."""
-    import pybind11_cross_module_tests as cm
-
-    m.register_mixed_global()
-    m.register_mixed_local()
-
-    a = []
-    a.append(m.MixedGlobalLocal(1))
-    a.append(m.MixedLocalGlobal(2))
-    a.append(m.get_mixed_gl(3))
-    a.append(m.get_mixed_lg(4))
-
-    assert [x.get() for x in a] == [101, 1002, 103, 1004]
-
-    cm.register_mixed_global_local()
-    cm.register_mixed_local_global()
-    a.append(m.MixedGlobalLocal(5))
-    a.append(m.MixedLocalGlobal(6))
-    a.append(cm.MixedGlobalLocal(7))
-    a.append(cm.MixedLocalGlobal(8))
-    a.append(m.get_mixed_gl(9))
-    a.append(m.get_mixed_lg(10))
-    a.append(cm.get_mixed_gl(11))
-    a.append(cm.get_mixed_lg(12))
-
-    assert [x.get() for x in a] == [
-        101,
-        1002,
-        103,
-        1004,
-        105,
-        1006,
-        207,
-        2008,
-        109,
-        1010,
-        211,
-        2012,
-    ]
-
-
-def test_internal_locals_differ():
-    """Makes sure the internal local type map differs across the two modules"""
-    import pybind11_cross_module_tests as cm
-
-    assert m.local_cpp_types_addr() != cm.local_cpp_types_addr()
-
-
-@pytest.mark.xfail("env.PYPY and sys.pypy_version_info < (7, 3, 2)")
-def test_stl_caster_vs_stl_bind(msg):
-    """One module uses a generic vector caster from `<pybind11/stl.h>` while the other
-    exports `std::vector<int>` via `py:bind_vector` and `py::module_local`"""
-    import pybind11_cross_module_tests as cm
-
-    v1 = cm.VectorInt([1, 2, 3])
-    assert m.load_vector_via_caster(v1) == 6
-    assert cm.load_vector_via_binding(v1) == 6
-
-    v2 = [1, 2, 3]
-    assert m.load_vector_via_caster(v2) == 6
-    with pytest.raises(TypeError) as excinfo:
-        cm.load_vector_via_binding(v2)
-    assert (
-        msg(excinfo.value)
-        == """
-    load_vector_via_binding(): incompatible function arguments. The following argument types are supported:
-        1. (arg0: pybind11_cross_module_tests.VectorInt) -> int
-
-    Invoked with: [1, 2, 3]
-    """  # noqa: E501 line too long
-    )
-
-
-def test_cross_module_calls():
-    import pybind11_cross_module_tests as cm
-
-    v1 = m.LocalVec()
-    v1.append(m.LocalType(1))
-    v2 = cm.LocalVec()
-    v2.append(cm.LocalType(2))
-
-    # Returning the self pointer should get picked up as returning an existing
-    # instance (even when that instance is of a foreign, non-local type).
-    assert m.return_self(v1) is v1
-    assert cm.return_self(v2) is v2
-    assert m.return_self(v2) is v2
-    assert cm.return_self(v1) is v1
-
-    assert m.LocalVec is not cm.LocalVec
-    # Returning a copy, on the other hand, always goes to the local type,
-    # regardless of where the source type came from.
-    assert type(m.return_copy(v1)) is m.LocalVec
-    assert type(m.return_copy(v2)) is m.LocalVec
-    assert type(cm.return_copy(v1)) is cm.LocalVec
-    assert type(cm.return_copy(v2)) is cm.LocalVec
-
-    # Test the example given in the documentation (which also tests inheritance casting):
-    mycat = m.Cat("Fluffy")
-    mydog = cm.Dog("Rover")
-    assert mycat.get_name() == "Fluffy"
-    assert mydog.name() == "Rover"
-    assert m.Cat.__base__.__name__ == "Pet"
-    assert cm.Dog.__base__.__name__ == "Pet"
-    assert m.Cat.__base__ is not cm.Dog.__base__
-    assert m.pet_name(mycat) == "Fluffy"
-    assert m.pet_name(mydog) == "Rover"
-    assert cm.pet_name(mycat) == "Fluffy"
-    assert cm.pet_name(mydog) == "Rover"
-
-    assert m.MixGL is not cm.MixGL
-    a = m.MixGL(1)
-    b = cm.MixGL(2)
-    assert m.get_gl_value(a) == 11
-    assert m.get_gl_value(b) == 12
-    assert cm.get_gl_value(a) == 101
-    assert cm.get_gl_value(b) == 102
-
-    c, d = m.MixGL2(3), cm.MixGL2(4)
-    with pytest.raises(TypeError) as excinfo:
-        m.get_gl_value(c)
-    assert "incompatible function arguments" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.get_gl_value(d)
-    assert "incompatible function arguments" in str(excinfo.value)