xcoll 0.5.11__py3-none-any.whl → 0.6.0__py3-none-any.whl

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

@@ -1,651 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import division
-
-import sys
-
-import pytest
-
-import env
-from pybind11_tests import debug_enabled
-from pybind11_tests import pytypes as m
-
-
-def test_int(doc):
-    assert doc(m.get_int) == "get_int() -> int"
-
-
-def test_iterator(doc):
-    assert doc(m.get_iterator) == "get_iterator() -> Iterator"
-
-
-def test_iterable(doc):
-    assert doc(m.get_iterable) == "get_iterable() -> Iterable"
-
-
-def test_list(capture, doc):
-    assert m.list_no_args() == []
-    assert m.list_ssize_t() == []
-    assert m.list_size_t() == []
-    lins = [1, 2]
-    m.list_insert_ssize_t(lins)
-    assert lins == [1, 83, 2]
-    m.list_insert_size_t(lins)
-    assert lins == [1, 83, 2, 57]
-
-    with capture:
-        lst = m.get_list()
-        assert lst == ["inserted-0", "overwritten", "inserted-2"]
-
-        lst.append("value2")
-        m.print_list(lst)
-    assert (
-        capture.unordered
-        == """
-        Entry at position 0: value
-        list item 0: inserted-0
-        list item 1: overwritten
-        list item 2: inserted-2
-        list item 3: value2
-    """
-    )
-
-    assert doc(m.get_list) == "get_list() -> list"
-    assert doc(m.print_list) == "print_list(arg0: list) -> None"
-
-
-def test_none(capture, doc):
-    assert doc(m.get_none) == "get_none() -> None"
-    assert doc(m.print_none) == "print_none(arg0: None) -> None"
-
-
-def test_set(capture, doc):
-    s = m.get_set()
-    assert s == {"key1", "key2", "key3"}
-
-    with capture:
-        s.add("key4")
-        m.print_set(s)
-    assert (
-        capture.unordered
-        == """
-        key: key1
-        key: key2
-        key: key3
-        key: key4
-    """
-    )
-
-    assert not m.set_contains(set(), 42)
-    assert m.set_contains({42}, 42)
-    assert m.set_contains({"foo"}, "foo")
-
-    assert doc(m.get_list) == "get_list() -> list"
-    assert doc(m.print_list) == "print_list(arg0: list) -> None"
-
-
-def test_dict(capture, doc):
-    d = m.get_dict()
-    assert d == {"key": "value"}
-
-    with capture:
-        d["key2"] = "value2"
-        m.print_dict(d)
-    assert (
-        capture.unordered
-        == """
-        key: key, value=value
-        key: key2, value=value2
-    """
-    )
-
-    assert not m.dict_contains({}, 42)
-    assert m.dict_contains({42: None}, 42)
-    assert m.dict_contains({"foo": None}, "foo")
-
-    assert doc(m.get_dict) == "get_dict() -> dict"
-    assert doc(m.print_dict) == "print_dict(arg0: dict) -> None"
-
-    assert m.dict_keyword_constructor() == {"x": 1, "y": 2, "z": 3}
-
-
-def test_tuple():
-    assert m.tuple_no_args() == ()
-    assert m.tuple_ssize_t() == ()
-    assert m.tuple_size_t() == ()
-    assert m.get_tuple() == (42, None, "spam")
-
-
-@pytest.mark.skipif("env.PY2")
-def test_simple_namespace():
-    ns = m.get_simple_namespace()
-    assert ns.attr == 42
-    assert ns.x == "foo"
-    assert ns.right == 2
-    assert not hasattr(ns, "wrong")
-
-
-def test_str(doc):
-    assert m.str_from_char_ssize_t().encode().decode() == "red"
-    assert m.str_from_char_size_t().encode().decode() == "blue"
-    assert m.str_from_string().encode().decode() == "baz"
-    assert m.str_from_bytes().encode().decode() == "boo"
-
-    assert doc(m.str_from_bytes) == "str_from_bytes() -> str"
-
-    class A(object):
-        def __str__(self):
-            return "this is a str"
-
-        def __repr__(self):
-            return "this is a repr"
-
-    assert m.str_from_object(A()) == "this is a str"
-    assert m.repr_from_object(A()) == "this is a repr"
-    assert m.str_from_handle(A()) == "this is a str"
-
-    s1, s2 = m.str_format()
-    assert s1 == "1 + 2 = 3"
-    assert s1 == s2
-
-    malformed_utf8 = b"\x80"
-    if hasattr(m, "PYBIND11_STR_LEGACY_PERMISSIVE"):
-        assert m.str_from_object(malformed_utf8) is malformed_utf8
-    elif env.PY2:
-        with pytest.raises(UnicodeDecodeError):
-            m.str_from_object(malformed_utf8)
-    else:
-        assert m.str_from_object(malformed_utf8) == "b'\\x80'"
-    if env.PY2:
-        with pytest.raises(UnicodeDecodeError):
-            m.str_from_handle(malformed_utf8)
-    else:
-        assert m.str_from_handle(malformed_utf8) == "b'\\x80'"
-
-    assert m.str_from_string_from_str("this is a str") == "this is a str"
-    ucs_surrogates_str = u"\udcc3"
-    if env.PY2:
-        assert u"\udcc3" == m.str_from_string_from_str(ucs_surrogates_str)
-    else:
-        with pytest.raises(UnicodeEncodeError):
-            m.str_from_string_from_str(ucs_surrogates_str)
-
-
-def test_bytes(doc):
-    assert m.bytes_from_char_ssize_t().decode() == "green"
-    assert m.bytes_from_char_size_t().decode() == "purple"
-    assert m.bytes_from_string().decode() == "foo"
-    assert m.bytes_from_str().decode() == "bar"
-
-    assert doc(m.bytes_from_str) == "bytes_from_str() -> {}".format(
-        "str" if env.PY2 else "bytes"
-    )
-
-
-def test_bytearray(doc):
-    assert m.bytearray_from_char_ssize_t().decode() == "$%"
-    assert m.bytearray_from_char_size_t().decode() == "@$!"
-    assert m.bytearray_from_string().decode() == "foo"
-    assert m.bytearray_size() == len("foo")
-
-
-def test_capsule(capture):
-    pytest.gc_collect()
-    with capture:
-        a = m.return_capsule_with_destructor()
-        del a
-        pytest.gc_collect()
-    assert (
-        capture.unordered
-        == """
-        creating capsule
-        destructing capsule
-    """
-    )
-
-    with capture:
-        a = m.return_capsule_with_destructor_2()
-        del a
-        pytest.gc_collect()
-    assert (
-        capture.unordered
-        == """
-        creating capsule
-        destructing capsule: 1234
-    """
-    )
-
-    with capture:
-        a = m.return_capsule_with_name_and_destructor()
-        del a
-        pytest.gc_collect()
-    assert (
-        capture.unordered
-        == """
-        created capsule (1234, 'pointer type description')
-        destructing capsule (1234, 'pointer type description')
-    """
-    )
-
-
-def test_accessors():
-    class SubTestObject:
-        attr_obj = 1
-        attr_char = 2
-
-    class TestObject:
-        basic_attr = 1
-        begin_end = [1, 2, 3]
-        d = {"operator[object]": 1, "operator[char *]": 2}
-        sub = SubTestObject()
-
-        def func(self, x, *args):
-            return self.basic_attr + x + sum(args)
-
-    d = m.accessor_api(TestObject())
-    assert d["basic_attr"] == 1
-    assert d["begin_end"] == [1, 2, 3]
-    assert d["operator[object]"] == 1
-    assert d["operator[char *]"] == 2
-    assert d["attr(object)"] == 1
-    assert d["attr(char *)"] == 2
-    assert d["missing_attr_ptr"] == "raised"
-    assert d["missing_attr_chain"] == "raised"
-    assert d["is_none"] is False
-    assert d["operator()"] == 2
-    assert d["operator*"] == 7
-    assert d["implicit_list"] == [1, 2, 3]
-    assert all(x in TestObject.__dict__ for x in d["implicit_dict"])
-
-    assert m.tuple_accessor(tuple()) == (0, 1, 2)
-
-    d = m.accessor_assignment()
-    assert d["get"] == 0
-    assert d["deferred_get"] == 0
-    assert d["set"] == 1
-    assert d["deferred_set"] == 1
-    assert d["var"] == 99
-
-
-def test_constructors():
-    """C++ default and converting constructors are equivalent to type calls in Python"""
-    types = [bytes, bytearray, str, bool, int, float, tuple, list, dict, set]
-    expected = {t.__name__: t() for t in types}
-    if env.PY2:
-        # Note that bytes.__name__ == 'str' in Python 2.
-        # pybind11::str is unicode even under Python 2.
-        expected["bytes"] = bytes()
-        expected["str"] = unicode()  # noqa: F821
-    assert m.default_constructors() == expected
-
-    data = {
-        bytes: b"41",  # Currently no supported or working conversions.
-        bytearray: bytearray(b"41"),
-        str: 42,
-        bool: "Not empty",
-        int: "42",
-        float: "+1e3",
-        tuple: range(3),
-        list: range(3),
-        dict: [("two", 2), ("one", 1), ("three", 3)],
-        set: [4, 4, 5, 6, 6, 6],
-        memoryview: b"abc",
-    }
-    inputs = {k.__name__: v for k, v in data.items()}
-    expected = {k.__name__: k(v) for k, v in data.items()}
-    if env.PY2:  # Similar to the above. See comments above.
-        inputs["bytes"] = b"41"
-        inputs["str"] = 42
-        expected["bytes"] = b"41"
-        expected["str"] = u"42"
-
-    assert m.converting_constructors(inputs) == expected
-    assert m.cast_functions(inputs) == expected
-
-    # Converting constructors and cast functions should just reference rather
-    # than copy when no conversion is needed:
-    noconv1 = m.converting_constructors(expected)
-    for k in noconv1:
-        assert noconv1[k] is expected[k]
-
-    noconv2 = m.cast_functions(expected)
-    for k in noconv2:
-        assert noconv2[k] is expected[k]
-
-
-def test_non_converting_constructors():
-    non_converting_test_cases = [
-        ("bytes", range(10)),
-        ("none", 42),
-        ("ellipsis", 42),
-        ("type", 42),
-    ]
-    for t, v in non_converting_test_cases:
-        for move in [True, False]:
-            with pytest.raises(TypeError) as excinfo:
-                m.nonconverting_constructor(t, v, move)
-            expected_error = "Object of type '{}' is not an instance of '{}'".format(
-                type(v).__name__, t
-            )
-            assert str(excinfo.value) == expected_error
-
-
-def test_pybind11_str_raw_str():
-    # specifically to exercise pybind11::str::raw_str
-    cvt = m.convert_to_pybind11_str
-    assert cvt(u"Str") == u"Str"
-    assert cvt(b"Bytes") == u"Bytes" if env.PY2 else "b'Bytes'"
-    assert cvt(None) == u"None"
-    assert cvt(False) == u"False"
-    assert cvt(True) == u"True"
-    assert cvt(42) == u"42"
-    assert cvt(2 ** 65) == u"36893488147419103232"
-    assert cvt(-1.50) == u"-1.5"
-    assert cvt(()) == u"()"
-    assert cvt((18,)) == u"(18,)"
-    assert cvt([]) == u"[]"
-    assert cvt([28]) == u"[28]"
-    assert cvt({}) == u"{}"
-    assert cvt({3: 4}) == u"{3: 4}"
-    assert cvt(set()) == u"set([])" if env.PY2 else "set()"
-    assert cvt({3, 3}) == u"set([3])" if env.PY2 else "{3}"
-
-    valid_orig = u"DZ"
-    valid_utf8 = valid_orig.encode("utf-8")
-    valid_cvt = cvt(valid_utf8)
-    if hasattr(m, "PYBIND11_STR_LEGACY_PERMISSIVE"):
-        assert valid_cvt is valid_utf8
-    else:
-        assert type(valid_cvt) is unicode if env.PY2 else str  # noqa: F821
-        if env.PY2:
-            assert valid_cvt == valid_orig
-        else:
-            assert valid_cvt == "b'\\xc7\\xb1'"
-
-    malformed_utf8 = b"\x80"
-    if hasattr(m, "PYBIND11_STR_LEGACY_PERMISSIVE"):
-        assert cvt(malformed_utf8) is malformed_utf8
-    else:
-        if env.PY2:
-            with pytest.raises(UnicodeDecodeError):
-                cvt(malformed_utf8)
-        else:
-            malformed_cvt = cvt(malformed_utf8)
-            assert type(malformed_cvt) is str
-            assert malformed_cvt == "b'\\x80'"
-
-
-def test_implicit_casting():
-    """Tests implicit casting when assigning or appending to dicts and lists."""
-    z = m.get_implicit_casting()
-    assert z["d"] == {
-        "char*_i1": "abc",
-        "char*_i2": "abc",
-        "char*_e": "abc",
-        "char*_p": "abc",
-        "str_i1": "str",
-        "str_i2": "str1",
-        "str_e": "str2",
-        "str_p": "str3",
-        "int_i1": 42,
-        "int_i2": 42,
-        "int_e": 43,
-        "int_p": 44,
-    }
-    assert z["l"] == [3, 6, 9, 12, 15]
-
-
-def test_print(capture):
-    with capture:
-        m.print_function()
-    assert (
-        capture
-        == """
-        Hello, World!
-        1 2.0 three True -- multiple args
-        *args-and-a-custom-separator
-        no new line here -- next print
-        flush
-        py::print + str.format = this
-    """
-    )
-    assert capture.stderr == "this goes to stderr"
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.print_failure()
-    assert str(excinfo.value) == "Unable to convert call argument " + (
-        "'1' of type 'UnregisteredType' to Python object"
-        if debug_enabled
-        else "to Python object (compile in debug mode for details)"
-    )
-
-
-def test_hash():
-    class Hashable(object):
-        def __init__(self, value):
-            self.value = value
-
-        def __hash__(self):
-            return self.value
-
-    class Unhashable(object):
-        __hash__ = None
-
-    assert m.hash_function(Hashable(42)) == 42
-    with pytest.raises(TypeError):
-        m.hash_function(Unhashable())
-
-
-def test_number_protocol():
-    for a, b in [(1, 1), (3, 5)]:
-        li = [
-            a == b,
-            a != b,
-            a < b,
-            a <= b,
-            a > b,
-            a >= b,
-            a + b,
-            a - b,
-            a * b,
-            a / b,
-            a | b,
-            a & b,
-            a ^ b,
-            a >> b,
-            a << b,
-        ]
-        assert m.test_number_protocol(a, b) == li
-
-
-def test_list_slicing():
-    li = list(range(100))
-    assert li[::2] == m.test_list_slicing(li)
-
-
-def test_issue2361():
-    # See issue #2361
-    assert m.issue2361_str_implicit_copy_none() == "None"
-    with pytest.raises(TypeError) as excinfo:
-        assert m.issue2361_dict_implicit_copy_none()
-    assert "NoneType" in str(excinfo.value)
-    assert "iterable" in str(excinfo.value)
-
-
-@pytest.mark.parametrize(
-    "method, args, fmt, expected_view",
-    [
-        (m.test_memoryview_object, (b"red",), "B", b"red"),
-        (m.test_memoryview_buffer_info, (b"green",), "B", b"green"),
-        (m.test_memoryview_from_buffer, (False,), "h", [3, 1, 4, 1, 5]),
-        (m.test_memoryview_from_buffer, (True,), "H", [2, 7, 1, 8]),
-        (m.test_memoryview_from_buffer_nativeformat, (), "@i", [4, 7, 5]),
-    ],
-)
-def test_memoryview(method, args, fmt, expected_view):
-    view = method(*args)
-    assert isinstance(view, memoryview)
-    assert view.format == fmt
-    if isinstance(expected_view, bytes) or not env.PY2:
-        view_as_list = list(view)
-    else:
-        # Using max to pick non-zero byte (big-endian vs little-endian).
-        view_as_list = [max(ord(c) for c in s) for s in view]
-    assert view_as_list == list(expected_view)
-
-
-@pytest.mark.xfail("env.PYPY", reason="getrefcount is not available")
-@pytest.mark.parametrize(
-    "method",
-    [
-        m.test_memoryview_object,
-        m.test_memoryview_buffer_info,
-    ],
-)
-def test_memoryview_refcount(method):
-    buf = b"\x0a\x0b\x0c\x0d"
-    ref_before = sys.getrefcount(buf)
-    view = method(buf)
-    ref_after = sys.getrefcount(buf)
-    assert ref_before < ref_after
-    assert list(view) == list(buf)
-
-
-def test_memoryview_from_buffer_empty_shape():
-    view = m.test_memoryview_from_buffer_empty_shape()
-    assert isinstance(view, memoryview)
-    assert view.format == "B"
-    if env.PY2:
-        # Python 2 behavior is weird, but Python 3 (the future) is fine.
-        # PyPy3 has <memoryview, while CPython 2 has <memory
-        assert bytes(view).startswith(b"<memory")
-    else:
-        assert bytes(view) == b""
-
-
-def test_test_memoryview_from_buffer_invalid_strides():
-    with pytest.raises(RuntimeError):
-        m.test_memoryview_from_buffer_invalid_strides()
-
-
-def test_test_memoryview_from_buffer_nullptr():
-    if env.PY2:
-        m.test_memoryview_from_buffer_nullptr()
-    else:
-        with pytest.raises(ValueError):
-            m.test_memoryview_from_buffer_nullptr()
-
-
-@pytest.mark.skipif("env.PY2")
-def test_memoryview_from_memory():
-    view = m.test_memoryview_from_memory()
-    assert isinstance(view, memoryview)
-    assert view.format == "B"
-    assert bytes(view) == b"\xff\xe1\xab\x37"
-
-
-def test_builtin_functions():
-    assert m.get_len([i for i in range(42)]) == 42
-    with pytest.raises(TypeError) as exc_info:
-        m.get_len(i for i in range(42))
-    assert str(exc_info.value) in [
-        "object of type 'generator' has no len()",
-        "'generator' has no length",
-    ]  # PyPy
-
-
-def test_isinstance_string_types():
-    assert m.isinstance_pybind11_bytes(b"")
-    assert not m.isinstance_pybind11_bytes(u"")
-
-    assert m.isinstance_pybind11_str(u"")
-    if hasattr(m, "PYBIND11_STR_LEGACY_PERMISSIVE"):
-        assert m.isinstance_pybind11_str(b"")
-    else:
-        assert not m.isinstance_pybind11_str(b"")
-
-
-def test_pass_bytes_or_unicode_to_string_types():
-    assert m.pass_to_pybind11_bytes(b"Bytes") == 5
-    with pytest.raises(TypeError):
-        m.pass_to_pybind11_bytes(u"Str")
-
-    if hasattr(m, "PYBIND11_STR_LEGACY_PERMISSIVE") or env.PY2:
-        assert m.pass_to_pybind11_str(b"Bytes") == 5
-    else:
-        with pytest.raises(TypeError):
-            m.pass_to_pybind11_str(b"Bytes")
-    assert m.pass_to_pybind11_str(u"Str") == 3
-
-    assert m.pass_to_std_string(b"Bytes") == 5
-    assert m.pass_to_std_string(u"Str") == 3
-
-    malformed_utf8 = b"\x80"
-    if hasattr(m, "PYBIND11_STR_LEGACY_PERMISSIVE"):
-        assert m.pass_to_pybind11_str(malformed_utf8) == 1
-    elif env.PY2:
-        with pytest.raises(UnicodeDecodeError):
-            m.pass_to_pybind11_str(malformed_utf8)
-    else:
-        with pytest.raises(TypeError):
-            m.pass_to_pybind11_str(malformed_utf8)
-
-
-@pytest.mark.parametrize(
-    "create_weakref, create_weakref_with_callback",
-    [
-        (m.weakref_from_handle, m.weakref_from_handle_and_function),
-        (m.weakref_from_object, m.weakref_from_object_and_function),
-    ],
-)
-def test_weakref(create_weakref, create_weakref_with_callback):
-    from weakref import getweakrefcount
-
-    # Apparently, you cannot weakly reference an object()
-    class WeaklyReferenced(object):
-        pass
-
-    def callback(wr):
-        # No `nonlocal` in Python 2
-        callback.called = True
-
-    obj = WeaklyReferenced()
-    assert getweakrefcount(obj) == 0
-    wr = create_weakref(obj)
-    assert getweakrefcount(obj) == 1
-
-    obj = WeaklyReferenced()
-    assert getweakrefcount(obj) == 0
-    callback.called = False
-    wr = create_weakref_with_callback(obj, callback)  # noqa: F841
-    assert getweakrefcount(obj) == 1
-    assert not callback.called
-    del obj
-    pytest.gc_collect()
-    assert callback.called
-
-
-def test_cpp_iterators():
-    assert m.tuple_iterator() == 12
-    assert m.dict_iterator() == 305 + 711
-    assert m.passed_iterator(iter((-7, 3))) == -4
-
-
-def test_implementation_details():
-    lst = [39, 43, 92, 49, 22, 29, 93, 98, 26, 57, 8]
-    tup = tuple(lst)
-    assert m.sequence_item_get_ssize_t(lst) == 43
-    assert m.sequence_item_set_ssize_t(lst) is None
-    assert lst[1] == "peppa"
-    assert m.sequence_item_get_size_t(lst) == 92
-    assert m.sequence_item_set_size_t(lst) is None
-    assert lst[2] == "george"
-    assert m.list_item_get_ssize_t(lst) == 49
-    assert m.list_item_set_ssize_t(lst) is None
-    assert lst[3] == "rebecca"
-    assert m.list_item_get_size_t(lst) == 22
-    assert m.list_item_set_size_t(lst) is None
-    assert lst[4] == "richard"
-    assert m.tuple_item_get_ssize_t(tup) == 29
-    assert m.tuple_item_set_ssize_t() == ("emely", "edmond")
-    assert m.tuple_item_get_size_t(tup) == 93
-    assert m.tuple_item_set_size_t() == ("candy", "cat")