def test_inverted_orderedbidict(ob_and_od):
""":func:`bidict.inverted` should yield the inverse items of an ordered bidict."""
ob, od = ob_and_od
od_inv = OrderedDict((v, k) for (k, v) in iteritems(od))
assert all(i == j for (i, j) in izip(inverted(ob), iteritems(od_inv)))
assert all(i == j
for (i, j) in izip(inverted(inverted(ob)), iteritems(od)))
def _lists_pairs_with_duplication(draw):
# pylint: disable=too-many-locals
n = draw(st.integers(min_value=3, max_value=LISTS_MAX_SIZE))
indexes = st.integers(min_value=0, max_value=n - 1)
keys = draw(st.lists(IMMUTABLES, min_size=n, max_size=n))
vals = draw(st.lists(IMMUTABLES, min_size=n, max_size=n))
fwd = OrderedDict(izip(keys, vals))
inv = OrderedDict(izip(vals, keys))
which_to_dup = draw(RAND).choice((1, 2, 3))
should_dup_key = which_to_dup in (1, 3)
should_dup_val = which_to_dup in (2, 3)
should_add_dup_key = should_dup_key and len(fwd) < n
should_add_dup_val = should_dup_val and len(inv) < n
if not should_add_dup_key and not should_add_dup_val:
return list(izip(keys, vals))
if should_add_dup_key:
dup_key_idx = draw(indexes)
added_key = keys[dup_key_idx]
else:
added_key = draw(IMMUTABLES)
assume(added_key not in fwd)
if should_add_dup_val:
dup_val_idx = draw(indexes)
if should_add_dup_key:
assume(dup_val_idx != dup_key_idx)
added_val = vals[dup_val_idx]
else:
added_val = draw(IMMUTABLES)
assume(added_val not in inv)
insert_idx = draw(indexes)
keys.insert(insert_idx, added_key)
vals.insert(insert_idx, added_val)
return list(izip(keys, vals))
def _lists_pairs_with_duplication(draw):
# pylint: disable=too-many-locals
n = draw(st.integers(min_value=3, max_value=LISTS_MAX_SIZE))
indexes = st.integers(min_value=0, max_value=n - 1)
keys = draw(st.lists(IMMUTABLES, min_size=n, max_size=n))
vals = draw(st.lists(IMMUTABLES, min_size=n, max_size=n))
fwd = OrderedDict(izip(keys, vals))
inv = OrderedDict(izip(vals, keys))
which_to_dup = draw(RAND).choice((1, 2, 3))
should_dup_key = which_to_dup in (1, 3)
should_dup_val = which_to_dup in (2, 3)
should_add_dup_key = should_dup_key and len(fwd) < n
should_add_dup_val = should_dup_val and len(inv) < n
if not should_add_dup_key and not should_add_dup_val:
return list(izip(keys, vals))
if should_add_dup_key:
dup_key_idx = draw(indexes)
added_key = keys[dup_key_idx]
else:
added_key = draw(IMMUTABLES)
assume(added_key not in fwd)
if should_add_dup_val:
dup_val_idx = draw(indexes)
if should_add_dup_key:
assume(dup_val_idx != dup_key_idx)
added_val = vals[dup_val_idx]
else:
added_val = draw(IMMUTABLES)
assume(added_val not in inv)
insert_idx = draw(indexes)
keys.insert(insert_idx, added_key)
vals.insert(insert_idx, added_val)
return list(izip(keys, vals))
def test_orderedbidict_iter(ob_cls, init_items):
""":meth:`bidict.OrderedBidictBase.__iter__` should yield all the keys
in an ordered bidict in the order they were inserted.
"""
some_bidict = ob_cls(init_items)
key_iters = (some_bidict, iterkeys(some_bidict), (KEY(pair) for pair in init_items))
assert all(i == j == k for (i, j, k) in izip(*key_iters))
def lists_pairs_nodup(draw, elements=IMMUTABLES, min_size=0, max_size=LISTS_MAX_SIZE):
"""Generate a list of pairs from the given elements with no duplication."""
n = draw(st.integers(min_value=min_size, max_value=max_size))
size_n_sets = st.sets(elements, min_size=n, max_size=n)
keys = draw(size_n_sets)
vals = draw(size_n_sets)
return list(izip(keys, vals))
def test_orderedbidict_reversed(ob_cls, init_items):
""":meth:`bidict.OrderedBidictBase.__reversed__` should yield all the keys
in an ordered bidict in the reverse-order they were inserted.
"""
some_bidict = ob_cls(init_items)
key_seqs = (some_bidict, list(iterkeys(some_bidict)), [KEY(pair) for pair in init_items])
key_seqs_rev = (reversed(i) for i in key_seqs)
assert all(i == j == k for (i, j, k) in izip(*key_seqs_rev))
def lists_pairs_nodup(draw,
elements=IMMUTABLES,
min_size=0,
max_size=LISTS_MAX_SIZE):
"""Generate a list of pairs from the given elements with no duplication."""
n = draw(st.integers(min_value=min_size, max_value=max_size))
size_n_sets = st.sets(elements, min_size=n, max_size=n)
keys = draw(size_n_sets)
vals = draw(size_n_sets)
return list(izip(keys, vals))
def test_pairs(items, kwitems):
"""Test that :func:`bidict.pairs` works correctly."""
assert list(pairs(items)) == list(items)
assert list(pairs(OrderedDict(kwitems))) == list(kwitems)
kwdict = dict(kwitems)
pairs_it = pairs(items, **kwdict)
assert all(i == j for (i, j) in izip(items, pairs_it))
assert set(iteritems(kwdict)) == {i for i in pairs_it}
with pytest.raises(TypeError):
pairs('too', 'many', 'args')
def test_iteritems_args_kw(arg0_pairs, kw_pairs):
""":func:`bidict._iteritems_args_kw` should work correctly."""
assert list(_iteritems_args_kw(arg0_pairs)) == list(arg0_pairs)
assert list(_iteritems_args_kw(OrderedDict(kw_pairs))) == list(kw_pairs)
kwdict = dict(kw_pairs)
# Create an iterator over both arg0_pairs and kw_pairs.
arg0_kw_items = _iteritems_args_kw(arg0_pairs, **kwdict)
# Consume the initial (arg0) pairs of the iterator, checking they match arg0.
assert all(check == expect for (check, expect) in izip(arg0_kw_items, arg0_pairs))
# Consume the remaining (kw) pairs of the iterator, checking they match kw.
assert all(kwdict[k] == v for (k, v) in arg0_kw_items)
with pytest.raises(StopIteration):
next(arg0_kw_items)
def test_iteritems_args_kw(arg0_pairs, kw_pairs):
""":func:`bidict._iteritems_args_kw` should work correctly."""
assert list(_iteritems_args_kw(arg0_pairs)) == list(arg0_pairs)
assert list(_iteritems_args_kw(OrderedDict(kw_pairs))) == list(kw_pairs)
kwdict = dict(kw_pairs)
# Create an iterator over both arg0_pairs and kw_pairs.
arg0_kw_items = _iteritems_args_kw(arg0_pairs, **kwdict)
# Consume the initial (arg0) pairs of the iterator, checking they match arg0.
assert all(check == expect
for (check, expect) in izip(arg0_kw_items, arg0_pairs))
# Consume the remaining (kw) pairs of the iterator, checking they match kw.
assert all(kwdict[k] == v for (k, v) in arg0_kw_items)
with pytest.raises(StopIteration):
next(arg0_kw_items)
def test_inverted_orderedbidict(ob_and_od):
""":func:`bidict.inverted` should yield the inverse items of an ordered bidict."""
ob, od = ob_and_od
od_inv = OrderedDict((v, k) for (k, v) in iteritems(od))
assert all(i == j for (i, j) in izip(inverted(ob), iteritems(od_inv)))
assert all(i == j for (i, j) in izip(inverted(inverted(ob)), iteritems(od)))
def test_orderedbidict_reversed(ob_and_od):
""":meth:`bidict.OrderedBidictBase.__reversed__` should yield all the keys
in an ordered bidict in the reverse-order they were inserted.
"""
ob, od = ob_and_od
assert all(i == j for (i, j) in izip(reversed(ob), reversed(od)))
def test_orderedbidict_iter(ob_and_od):
"""Ordered bidict __iter__ should yield all the keys in an ordered bidict in the right order."""
ob, od = ob_and_od
assert all(i == j for (i, j) in izip(ob, od))
def test_orderedbidict_reversed(ob_and_od):
""":meth:`bidict.OrderedBidictBase.__reversed__` should yield all the keys
in an ordered bidict in the reverse-order they were inserted.
"""
ob, od = ob_and_od
assert all(i == j for (i, j) in izip(reversed(ob), reversed(od)))
def test_orderedbidict_iter(ob_and_od):
"""Ordered bidict __iter__ should yield all the keys in an ordered bidict in the right order."""
ob, od = ob_and_od
assert all(i == j for (i, j) in izip(ob, od))
def test_orderedbidict_reversed(bi_cls, init_items):
"""Ensure :meth:`bidict.OrderedBidictBase.__reversed__` works correctly."""
some_bidict = bi_cls(init_items)
assert all(i == j for (i, j) in izip(reversed(some_bidict),
list(iterkeys(some_bidict))[::-1]))
def test_orderedbidict_iter(bi_cls, init_items):
"""Ensure :meth:`bidict.OrderedBidictBase.__iter__` works correctly."""
some_bidict = bi_cls(init_items)
assert all(i == j for (i, j) in izip(some_bidict, iterkeys(some_bidict)))
