mirror of
https://gitlab.com/kicad/code/kicad.git
synced 2024-11-22 02:25:06 +00:00
2533141583
This reverts commits9d077c9ba5andb4938f5198. They cause a crash-on-startup on Mac ARM machines, failing to get the locale encoding (nl_langinfo(CODESET) failed).
254 lines
7.9 KiB
Python
254 lines
7.9 KiB
Python
# -*- coding: utf-8 -*-
|
|
import pytest
|
|
|
|
from pybind11_tests import ConstructorStats
|
|
from pybind11_tests import sequences_and_iterators as m
|
|
|
|
|
|
def isclose(a, b, rel_tol=1e-05, abs_tol=0.0):
|
|
"""Like math.isclose() from Python 3.5"""
|
|
return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
|
|
|
|
|
|
def allclose(a_list, b_list, rel_tol=1e-05, abs_tol=0.0):
|
|
return all(
|
|
isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol) for a, b in zip(a_list, b_list)
|
|
)
|
|
|
|
|
|
def test_slice_constructors():
|
|
assert m.make_forward_slice_size_t() == slice(0, -1, 1)
|
|
assert m.make_reversed_slice_object() == slice(None, None, -1)
|
|
|
|
|
|
@pytest.mark.skipif(not m.has_optional, reason="no <optional>")
|
|
def test_slice_constructors_explicit_optional():
|
|
assert m.make_reversed_slice_size_t_optional() == slice(None, None, -1)
|
|
assert m.make_reversed_slice_size_t_optional_verbose() == slice(None, None, -1)
|
|
|
|
|
|
def test_generalized_iterators():
|
|
assert list(m.IntPairs([(1, 2), (3, 4), (0, 5)]).nonzero()) == [(1, 2), (3, 4)]
|
|
assert list(m.IntPairs([(1, 2), (2, 0), (0, 3), (4, 5)]).nonzero()) == [(1, 2)]
|
|
assert list(m.IntPairs([(0, 3), (1, 2), (3, 4)]).nonzero()) == []
|
|
|
|
assert list(m.IntPairs([(1, 2), (3, 4), (0, 5)]).nonzero_keys()) == [1, 3]
|
|
assert list(m.IntPairs([(1, 2), (2, 0), (0, 3), (4, 5)]).nonzero_keys()) == [1]
|
|
assert list(m.IntPairs([(0, 3), (1, 2), (3, 4)]).nonzero_keys()) == []
|
|
|
|
assert list(m.IntPairs([(1, 2), (3, 4), (0, 5)]).nonzero_values()) == [2, 4]
|
|
assert list(m.IntPairs([(1, 2), (2, 0), (0, 3), (4, 5)]).nonzero_values()) == [2]
|
|
assert list(m.IntPairs([(0, 3), (1, 2), (3, 4)]).nonzero_values()) == []
|
|
|
|
# __next__ must continue to raise StopIteration
|
|
it = m.IntPairs([(0, 0)]).nonzero()
|
|
for _ in range(3):
|
|
with pytest.raises(StopIteration):
|
|
next(it)
|
|
|
|
it = m.IntPairs([(0, 0)]).nonzero_keys()
|
|
for _ in range(3):
|
|
with pytest.raises(StopIteration):
|
|
next(it)
|
|
|
|
|
|
def test_nonref_iterators():
|
|
pairs = m.IntPairs([(1, 2), (3, 4), (0, 5)])
|
|
assert list(pairs.nonref()) == [(1, 2), (3, 4), (0, 5)]
|
|
assert list(pairs.nonref_keys()) == [1, 3, 0]
|
|
assert list(pairs.nonref_values()) == [2, 4, 5]
|
|
|
|
|
|
def test_generalized_iterators_simple():
|
|
assert list(m.IntPairs([(1, 2), (3, 4), (0, 5)]).simple_iterator()) == [
|
|
(1, 2),
|
|
(3, 4),
|
|
(0, 5),
|
|
]
|
|
assert list(m.IntPairs([(1, 2), (3, 4), (0, 5)]).simple_keys()) == [1, 3, 0]
|
|
assert list(m.IntPairs([(1, 2), (3, 4), (0, 5)]).simple_values()) == [2, 4, 5]
|
|
|
|
|
|
def test_iterator_referencing():
|
|
"""Test that iterators reference rather than copy their referents."""
|
|
vec = m.VectorNonCopyableInt()
|
|
vec.append(3)
|
|
vec.append(5)
|
|
assert [int(x) for x in vec] == [3, 5]
|
|
# Increment everything to make sure the referents can be mutated
|
|
for x in vec:
|
|
x.set(int(x) + 1)
|
|
assert [int(x) for x in vec] == [4, 6]
|
|
|
|
vec = m.VectorNonCopyableIntPair()
|
|
vec.append([3, 4])
|
|
vec.append([5, 7])
|
|
assert [int(x) for x in vec.keys()] == [3, 5]
|
|
assert [int(x) for x in vec.values()] == [4, 7]
|
|
for x in vec.keys():
|
|
x.set(int(x) + 1)
|
|
for x in vec.values():
|
|
x.set(int(x) + 10)
|
|
assert [int(x) for x in vec.keys()] == [4, 6]
|
|
assert [int(x) for x in vec.values()] == [14, 17]
|
|
|
|
|
|
def test_sliceable():
|
|
sliceable = m.Sliceable(100)
|
|
assert sliceable[::] == (0, 100, 1)
|
|
assert sliceable[10::] == (10, 100, 1)
|
|
assert sliceable[:10:] == (0, 10, 1)
|
|
assert sliceable[::10] == (0, 100, 10)
|
|
assert sliceable[-10::] == (90, 100, 1)
|
|
assert sliceable[:-10:] == (0, 90, 1)
|
|
assert sliceable[::-10] == (99, -1, -10)
|
|
assert sliceable[50:60:1] == (50, 60, 1)
|
|
assert sliceable[50:60:-1] == (50, 60, -1)
|
|
|
|
|
|
def test_sequence():
|
|
cstats = ConstructorStats.get(m.Sequence)
|
|
|
|
s = m.Sequence(5)
|
|
assert cstats.values() == ["of size", "5"]
|
|
|
|
assert "Sequence" in repr(s)
|
|
assert len(s) == 5
|
|
assert s[0] == 0 and s[3] == 0
|
|
assert 12.34 not in s
|
|
s[0], s[3] = 12.34, 56.78
|
|
assert 12.34 in s
|
|
assert isclose(s[0], 12.34) and isclose(s[3], 56.78)
|
|
|
|
rev = reversed(s)
|
|
assert cstats.values() == ["of size", "5"]
|
|
|
|
rev2 = s[::-1]
|
|
assert cstats.values() == ["of size", "5"]
|
|
|
|
it = iter(m.Sequence(0))
|
|
for _ in range(3): # __next__ must continue to raise StopIteration
|
|
with pytest.raises(StopIteration):
|
|
next(it)
|
|
assert cstats.values() == ["of size", "0"]
|
|
|
|
expected = [0, 56.78, 0, 0, 12.34]
|
|
assert allclose(rev, expected)
|
|
assert allclose(rev2, expected)
|
|
assert rev == rev2
|
|
|
|
rev[0::2] = m.Sequence([2.0, 2.0, 2.0])
|
|
assert cstats.values() == ["of size", "3", "from std::vector"]
|
|
|
|
assert allclose(rev, [2, 56.78, 2, 0, 2])
|
|
|
|
assert cstats.alive() == 4
|
|
del it
|
|
assert cstats.alive() == 3
|
|
del s
|
|
assert cstats.alive() == 2
|
|
del rev
|
|
assert cstats.alive() == 1
|
|
del rev2
|
|
assert cstats.alive() == 0
|
|
|
|
assert cstats.values() == []
|
|
assert cstats.default_constructions == 0
|
|
assert cstats.copy_constructions == 0
|
|
assert cstats.move_constructions >= 1
|
|
assert cstats.copy_assignments == 0
|
|
assert cstats.move_assignments == 0
|
|
|
|
|
|
def test_sequence_length():
|
|
"""#2076: Exception raised by len(arg) should be propagated"""
|
|
|
|
class BadLen(RuntimeError):
|
|
pass
|
|
|
|
class SequenceLike:
|
|
def __getitem__(self, i):
|
|
return None
|
|
|
|
def __len__(self):
|
|
raise BadLen()
|
|
|
|
with pytest.raises(BadLen):
|
|
m.sequence_length(SequenceLike())
|
|
|
|
assert m.sequence_length([1, 2, 3]) == 3
|
|
assert m.sequence_length("hello") == 5
|
|
|
|
|
|
def test_map_iterator():
|
|
sm = m.StringMap({"hi": "bye", "black": "white"})
|
|
assert sm["hi"] == "bye"
|
|
assert len(sm) == 2
|
|
assert sm["black"] == "white"
|
|
|
|
with pytest.raises(KeyError):
|
|
assert sm["orange"]
|
|
sm["orange"] = "banana"
|
|
assert sm["orange"] == "banana"
|
|
|
|
expected = {"hi": "bye", "black": "white", "orange": "banana"}
|
|
for k in sm:
|
|
assert sm[k] == expected[k]
|
|
for k, v in sm.items():
|
|
assert v == expected[k]
|
|
assert list(sm.values()) == [expected[k] for k in sm]
|
|
|
|
it = iter(m.StringMap({}))
|
|
for _ in range(3): # __next__ must continue to raise StopIteration
|
|
with pytest.raises(StopIteration):
|
|
next(it)
|
|
|
|
|
|
def test_python_iterator_in_cpp():
|
|
t = (1, 2, 3)
|
|
assert m.object_to_list(t) == [1, 2, 3]
|
|
assert m.object_to_list(iter(t)) == [1, 2, 3]
|
|
assert m.iterator_to_list(iter(t)) == [1, 2, 3]
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.object_to_list(1)
|
|
assert "object is not iterable" in str(excinfo.value)
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.iterator_to_list(1)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
|
|
def bad_next_call():
|
|
raise RuntimeError("py::iterator::advance() should propagate errors")
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.iterator_to_list(iter(bad_next_call, None))
|
|
assert str(excinfo.value) == "py::iterator::advance() should propagate errors"
|
|
|
|
lst = [1, None, 0, None]
|
|
assert m.count_none(lst) == 2
|
|
assert m.find_none(lst) is True
|
|
assert m.count_nonzeros({"a": 0, "b": 1, "c": 2}) == 2
|
|
|
|
r = range(5)
|
|
assert all(m.tuple_iterator(tuple(r)))
|
|
assert all(m.list_iterator(list(r)))
|
|
assert all(m.sequence_iterator(r))
|
|
|
|
|
|
def test_iterator_passthrough():
|
|
"""#181: iterator passthrough did not compile"""
|
|
from pybind11_tests.sequences_and_iterators import iterator_passthrough
|
|
|
|
values = [3, 5, 7, 9, 11, 13, 15]
|
|
assert list(iterator_passthrough(iter(values))) == values
|
|
|
|
|
|
def test_iterator_rvp():
|
|
"""#388: Can't make iterators via make_iterator() with different r/v policies"""
|
|
import pybind11_tests.sequences_and_iterators as m
|
|
|
|
assert list(m.make_iterator_1()) == [1, 2, 3]
|
|
assert list(m.make_iterator_2()) == [1, 2, 3]
|
|
assert not isinstance(m.make_iterator_1(), type(m.make_iterator_2()))
|