def test_consistency_after_method_call(bi_and_cmp_dict, args_by_method):
"""A bidict should be left in a consistent state after calling any method, even if it raises."""
# pylint: disable=too-many-locals
bi_orig, cmp_dict_orig = bi_and_cmp_dict
for (_, methodname), args in iteritems(args_by_method):
if not hasattr(bi_orig, methodname):
continue
bi = bi_orig.copy()
method = getattr(bi, methodname)
try:
result = method(*args)
except (KeyError, BidictException) as exc:
# Call should fail clean, i.e. bi should be in the same state it was before the call.
assertmsg = '%r did not fail clean: %r' % (method, exc)
assert bi == bi_orig, assertmsg
assert bi.inv == bi_orig.inv, assertmsg
else:
# Should get the same result as calling the same method on the compare-to dict.
cmp_dict = cmp_dict_orig.copy()
cmp_dict_meth = getattr(cmp_dict, methodname, None)
if cmp_dict_meth:
cmp_result = cmp_dict_meth(*args)
if isinstance(cmp_result, c.Iterable):
coll = list if isinstance(bi, OrderedBidictBase) else set
result = coll(result)
cmp_result = coll(cmp_result)
assert result == cmp_result, 'methodname=%s, args=%r' % (methodname, args)
# Whether the call failed or succeeded, bi should pass consistency checks.
assert len(bi) == sum(1 for _ in iteritems(bi))
assert len(bi.inv) == sum(1 for _ in iteritems(bi.inv))
assert bi == dict(bi)
assert bi.inv == dict(bi.inv)
assert bi == OrderedDict((k, v) for (v, k) in iteritems(bi.inv))
assert bi.inv == OrderedDict((v, k) for (k, v) in iteritems(bi))
def test_namedbidict(base_type, init_items, data):
"""Test the :func:`bidict.namedbidict` factory and custom accessors."""
names = typename, keyname, valname = [data.draw(H_NAMES) for _ in range(3)]
try:
nbcls = namedbidict(typename, keyname, valname, base_type=base_type)
except ValueError:
# Either one of the names was invalid, or the keyname and valname were not distinct.
assert not all(map(NAMEDBIDICT_VALID_NAME.match,
names)) or keyname == valname
return
except TypeError:
# The base type must not have been a BidirectionalMapping.
assert not issubclass(base_type, BidirectionalMapping)
return
assume(init_items)
instance = nbcls(init_items)
valfor = getattr(instance, valname + '_for')
keyfor = getattr(instance, keyname + '_for')
assert all(valfor[key] == val for (key, val) in iteritems(instance))
assert all(keyfor[val] == key for (key, val) in iteritems(instance))
# The same custom accessors should work on the inverse.
inv = instance.inv
valfor = getattr(inv, valname + '_for')
keyfor = getattr(inv, keyname + '_for')
assert all(valfor[key] == val for (key, val) in iteritems(instance))
assert all(keyfor[val] == key for (key, val) in iteritems(instance))
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_consistency_after_mutation(bi_cls, init_items, method_args, data):
"""Call every mutating method on every bidict that implements it,
and ensure the bidict is left in a consistent state afterward.
"""
methodname, hs_args = method_args
method = getattr(bi_cls, methodname, None)
if not method:
return
args = tuple(data.draw(i) for i in hs_args)
bi_init = bi_cls(init_items)
bi_clone = bi_init.copy()
assert items_match(bi_init, bi_clone)
try:
method(bi_clone, *args)
except (KeyError, BidictException) as exc:
# Call should fail clean, i.e. bi_clone should be in the same state it was before the call.
assertmsg = '%r did not fail clean: %r' % (method, exc)
assert items_match(bi_clone, bi_init), assertmsg
assert items_match(bi_clone.inv, bi_init.inv), assertmsg
# Whether the call failed or succeeded, bi_clone should pass consistency checks.
assert len(bi_clone) == sum(1 for _ in iteritems(bi_clone))
assert len(bi_clone) == sum(1 for _ in iteritems(bi_clone.inv))
assert items_match(bi_clone, dict(bi_clone))
assert items_match(bi_clone.inv, dict(bi_clone.inv))
assert items_match(bi_clone, inverse_odict(iteritems(bi_clone.inv)))
assert items_match(bi_clone.inv, inverse_odict(iteritems(bi_clone)))
def test_consistency_after_mutation(arity, methodname, B, init, arg1, arg2,
items):
method = getattr(B, methodname, None)
if not method:
return
args = []
if arity == -1:
args.append(items)
else:
if arity > 0:
args.append(arg1)
if arity > 1:
args.append(arg2)
b0 = B(init)
b1 = b0.copy()
try:
method(b1, *args)
except:
# All methods should fail clean.
assert b1 == b0
assert b1.inv == b0.inv
return
# Method succeeded -> b1 should pass consistency checks.
assert b1 == to_inv_odict(iteritems(b1.inv))
assert b1.inv == to_inv_odict(iteritems(b1))
def test_consistency_after_method_call(bi_and_cmp_dict, args_by_method):
"""A bidict should be left in a consistent state after calling any method, even if it raises."""
# pylint: disable=too-many-locals
bi_orig, cmp_dict_orig = bi_and_cmp_dict
for (_, methodname), args in iteritems(args_by_method):
if not hasattr(bi_orig, methodname):
continue
bi = bi_orig.copy()
method = getattr(bi, methodname)
try:
result = method(*args)
except (KeyError, BidictException) as exc:
# Call should fail clean, i.e. bi should be in the same state it was before the call.
assertmsg = '%r did not fail clean: %r' % (method, exc)
assert bi == bi_orig, assertmsg
assert bi.inv == bi_orig.inv, assertmsg
else:
# Should get the same result as calling the same method on the compare-to dict.
cmp_dict = cmp_dict_orig.copy()
cmp_dict_meth = getattr(cmp_dict, methodname, None)
if cmp_dict_meth:
cmp_result = cmp_dict_meth(*args)
if isinstance(cmp_result, c.Iterable):
coll = list if isinstance(bi, OrderedBidictBase) else set
result = coll(result)
cmp_result = coll(cmp_result)
assert result == cmp_result, 'methodname=%s, args=%r' % (
methodname, args)
# Whether the call failed or succeeded, bi should pass consistency checks.
assert len(bi) == sum(1 for _ in iteritems(bi))
assert len(bi.inv) == sum(1 for _ in iteritems(bi.inv))
assert bi == dict(bi)
assert bi.inv == dict(bi.inv)
assert bi == OrderedDict((k, v) for (v, k) in iteritems(bi.inv))
assert bi.inv == OrderedDict((v, k) for (k, v) in iteritems(bi))
def items_match(map1, map2, relation=eq):
"""Ensure map1 and map2 contain the same items (and in the same order, if they're ordered)."""
both_ordered_bidicts = all(
isinstance(m, OrderedBidictBase) for m in (map1, map2))
canon = list if both_ordered_bidicts else set
canon_map1 = canon(iteritems(map1))
canon_map2 = canon(iteritems(map2))
return relation(canon_map1, canon_map2)
def test_bidirectional_mappings(B, init):
ordered = issubclass(B, OrderedBidirectionalMapping)
C = list if ordered else sorted
b = B(init)
keysf = C(k for (k, v) in iteritems(b))
keysi = C(b.inv[v] for (k, v) in iteritems(b))
assert keysf == keysi
valsf = C(b[k] for (v, k) in iteritems(b.inv))
valsi = C(v for (v, k) in iteritems(b.inv))
assert valsf == valsi
def test_bidirectional_mappings(B, init):
ordered = issubclass(B, OrderedBidirectionalMapping)
C = list if ordered else sorted
b = B(init)
keysf = C(k for (k, v) in iteritems(b))
keysi = C(b.inv[v] for (k, v) in iteritems(b))
assert keysf == keysi
valsf = C(b[k] for (v, k) in iteritems(b.inv))
valsi = C(v for (v, k) in iteritems(b.inv))
assert valsf == valsi
def test_bidirectional_mappings(B, init): # noqa
ordered = bool(getattr(B, '__reversed__', None))
C = list if ordered else sorted # noqa
b = B(init)
keysf = C(k for (k, v) in iteritems(b))
keysi = C(b.inv[v] for (k, v) in iteritems(b))
assert keysf == keysi
valsf = C(b[k] for (v, k) in iteritems(b.inv))
valsi = C(v for (v, k) in iteritems(b.inv))
assert valsf == valsi
def test_namedbidict(nb):
"""Test :func:`bidict.namedbidict` custom accessors."""
valfor = getattr(nb, nb._valname + '_for') # pylint: disable=protected-access
keyfor = getattr(nb, nb._keyname + '_for') # pylint: disable=protected-access
assert all(valfor[key] == val for (key, val) in iteritems(nb))
assert all(keyfor[val] == key for (key, val) in iteritems(nb))
# The same custom accessors should work on the inverse.
inv = nb.inv
valfor = getattr(inv, nb._valname + '_for') # pylint: disable=protected-access
keyfor = getattr(inv, nb._keyname + '_for') # pylint: disable=protected-access
assert all(valfor[key] == val for (key, val) in iteritems(nb))
assert all(keyfor[val] == key for (key, val) in iteritems(nb))
def test_namedbidict(nb):
"""Test :func:`bidict.namedbidict` custom accessors."""
valfor = getattr(nb, nb._valname + '_for') # pylint: disable=protected-access
keyfor = getattr(nb, nb._keyname + '_for') # pylint: disable=protected-access
assert all(valfor[key] == val for (key, val) in iteritems(nb))
assert all(keyfor[val] == key for (key, val) in iteritems(nb))
# The same custom accessors should work on the inverse.
inv = nb.inv
valfor = getattr(inv, nb._valname + '_for') # pylint: disable=protected-access
keyfor = getattr(inv, nb._keyname + '_for') # pylint: disable=protected-access
assert all(valfor[key] == val for (key, val) in iteritems(nb))
assert all(keyfor[val] == key for (key, val) in iteritems(nb))
def items_match(map1, map2, relation=eq):
"""Return whether the items of *map1* and *map2*
are related by *relation*.
If *map1* and *map2* are both ordered,
they will be compared as lists,
otherwise as sets.
"""
both_ordered_bidicts = all(
isinstance(m, OrderedBidictBase) for m in (map1, map2))
canon = list if both_ordered_bidicts else set
canon_map1 = canon(iteritems(map1))
canon_map2 = canon(iteritems(map2))
return relation(canon_map1, canon_map2)
def test_inverted_bidict(bi_and_cmp_dict):
""":func:`bidict.inverted` should yield the inverse items of a bidict."""
bi, cmp_dict = bi_and_cmp_dict
cmp_dict_inv = OrderedDict((v, k) for (k, v) in iteritems(cmp_dict))
assert set(inverted(bi)) == viewitems(cmp_dict_inv) == viewitems(bi.inv)
assert set(inverted(inverted(bi))) == viewitems(cmp_dict) == viewitems(
bi.inv.inv)
def test_equality(B, init):
b = B(init)
d = OrderedDict(init)
assert b == d
assert not b != d
i = to_inv_odict(iteritems(d))
assert b.inv == i
assert not b.inv != i
def test_equality(B, init):
b = B(init)
d = OrderedDict(init)
assert b == d
assert not b != d
i = to_inv_odict(iteritems(d))
assert b.inv == i
assert not b.inv != i
def test_equals_order_sensitive(ob_and_om):
"""Ordered bidicts should be order-sensitive-equal to ordered mappings with same nondup items.
The bidict's inverse and the ordered mapping's inverse should also be order-sensitive-equal.
"""
ob, om = ob_and_om
assert ob.equals_order_sensitive(om)
om_inv = OrderedDict((v, k) for (k, v) in iteritems(om))
assert ob.inv.equals_order_sensitive(om_inv)
def test_equals_order_sensitive(ob_and_om):
"""Ordered bidicts should be order-sensitive-equal to ordered mappings with same nondup items.
The bidict's inverse and the ordered mapping's inverse should also be order-sensitive-equal.
"""
ob, om = ob_and_om
assert ob.equals_order_sensitive(om)
om_inv = OrderedDict((v, k) for (k, v) in iteritems(om))
assert ob.inv.equals_order_sensitive(om_inv)
def test_consistency(bi_cls, init_items, setinv, method_args, data):
"""Every bidict should be left in a consistent state after calling
any method on it that it provides, even if the call raises.
"""
# pylint: disable=too-many-locals
methodname, hs_args = method_args
method = getattr(bi_cls, methodname, None)
if not method:
return
args = tuple(data.draw(i) for i in hs_args)
bi_called = bi_cls(init_items)
bi_pristine = bi_cls(init_items)
if setinv:
bi_called = bi_called.inv
bi_pristine = bi_pristine.inv
init_items = [(v, k) for (k, v) in init_items]
try:
result = method(bi_called, *args)
except (KeyError, BidictException) as exc:
# Call should fail clean, i.e. bi_called should be in the same state it was before the call.
assertmsg = '%r did not fail clean: %r' % (method, exc)
assert bi_called == bi_pristine, assertmsg
assert bi_called.inv == bi_pristine.inv, assertmsg
else:
ordered = issubclass(bi_cls, OrderedBidictBase)
dict_cls = OrderedDict if ordered else dict
dict_meth = getattr(dict_cls, methodname, None)
if dict_meth:
compare_dict = dict_cls(init_items)
dict_result = dict_meth(compare_dict, *args)
if isinstance(dict_result, c.Iterable):
collection = list if ordered else set
result = collection(result)
dict_result = collection(dict_result)
assert result == dict_result
# Whether the call failed or succeeded, bi_called should pass consistency checks.
assert len(bi_called) == sum(1 for _ in iteritems(bi_called))
assert len(bi_called.inv) == sum(1 for _ in iteritems(bi_called.inv))
assert bi_called == dict(bi_called)
assert bi_called.inv == dict(bi_called.inv)
assert bi_called == OrderedDict(
(k, v) for (v, k) in iteritems(bi_called.inv))
assert bi_called.inv == OrderedDict(
(v, k) for (k, v) in iteritems(bi_called))
def test_eq_ne_hash(bi_cls, other_cls, init_items, init_unequal,
not_a_mapping):
"""Test various equality comparisons and hashes between bidicts and other objects."""
assume(init_items != init_unequal)
some_bidict = bi_cls(init_items)
other_equal = other_cls(init_items)
other_equal_inv = inverse_odict(iteritems(other_equal))
assert items_match(some_bidict, other_equal)
assert items_match(some_bidict.inv, other_equal_inv)
assert some_bidict == other_equal
assert not some_bidict != other_equal
assert some_bidict.inv == other_equal_inv
assert not some_bidict.inv != other_equal_inv
has_eq_order_sens = getattr(bi_cls, 'equals_order_sensitive', None)
other_is_ordered = getattr(other_cls, '__reversed__', None)
if has_eq_order_sens and other_is_ordered:
assert some_bidict.equals_order_sensitive(other_equal)
assert some_bidict.inv.equals_order_sensitive(other_equal_inv)
both_hashable = all(
issubclass(cls, Hashable) for cls in (bi_cls, other_cls))
if both_hashable:
assert hash(some_bidict) == hash(other_equal)
other_unequal = other_cls(init_unequal)
other_unequal_inv = inverse_odict(iteritems(other_unequal))
assert items_match(some_bidict, other_unequal, relation=ne)
assert items_match(some_bidict.inv, other_unequal_inv, relation=ne)
assert some_bidict != other_unequal
assert not some_bidict == other_unequal
assert some_bidict.inv != other_unequal_inv
assert not some_bidict.inv == other_unequal_inv
if has_eq_order_sens:
assert not some_bidict.equals_order_sensitive(other_unequal)
assert not some_bidict.inv.equals_order_sensitive(other_unequal_inv)
assert not some_bidict == not_a_mapping
assert not some_bidict.inv == not_a_mapping
assert some_bidict != not_a_mapping
assert some_bidict.inv != not_a_mapping
if has_eq_order_sens:
assert not some_bidict.equals_order_sensitive(not_a_mapping)
assert not some_bidict.inv.equals_order_sensitive(not_a_mapping)
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_equal_to_mapping_with_same_items(bidict_and_mapping_from_same_items_nodup):
"""Bidicts should be equal to mappings created from the same non-duplicating items.
The bidict's inverse and the mapping's inverse should also be equal.
"""
bi, mapping = bidict_and_mapping_from_same_items_nodup
assert bi == mapping
assert not bi != mapping
mapping_inv = OrderedDict((v, k) for (k, v) in iteritems(mapping))
assert bi.inv == mapping_inv
assert not bi.inv != mapping_inv
def _wrapped(items): # noqa: E306 (expected 1 blank line before a nested definition)
fwd = dict(items)
if key:
assume(len(fwd) < len(items))
if val:
inv = dict((v, k) for (k, v) in items)
assume(len(inv) < len(items))
if key and val:
invinv = dict((v, k) for (k, v) in iteritems(inv))
# If an item has a duplicate key and val, they must duplicate two other distinct items.
assume(len(invinv) < len(fwd))
return items
def test_unequal_order_sensitive_same_items_different_order(ob_and_om):
"""Ordered bidicts should be order-sensitive-unequal to ordered mappings of diff-ordered items.
Where both were created from the same items where no key or value was duplicated,
but the items were ordered differently.
The bidict's inverse and the ordered mapping's inverse should also be order-sensitive-unequal.
"""
ob, om = ob_and_om
assert not ob.equals_order_sensitive(om)
om_inv = OrderedDict((v, k) for (k, v) in iteritems(om))
assert not ob.inv.equals_order_sensitive(om_inv)
def test_unequal_order_sensitive_same_items_different_order(ob_and_om):
"""Ordered bidicts should be order-sensitive-unequal to ordered mappings of diff-ordered items.
Where both were created from the same items where no key or value was duplicated,
but the items were ordered differently.
The bidict's inverse and the ordered mapping's inverse should also be order-sensitive-unequal.
"""
ob, om = ob_and_om
assert not ob.equals_order_sensitive(om)
om_inv = OrderedDict((v, k) for (k, v) in iteritems(om))
assert not ob.inv.equals_order_sensitive(om_inv)
def test_equal_to_mapping_with_same_items(
bidict_and_mapping_from_same_items_nodup):
"""Bidicts should be equal to mappings created from the same non-duplicating items.
The bidict's inverse and the mapping's inverse should also be equal.
"""
bi, mapping = bidict_and_mapping_from_same_items_nodup
assert bi == mapping
assert not bi != mapping
mapping_inv = OrderedDict((v, k) for (k, v) in iteritems(mapping))
assert bi.inv == mapping_inv
assert not bi.inv != mapping_inv
def test_consistency_after_mutation(arity, methodname, B, init, arg1, arg2,
items):
"""
Call every mutating method on every bidict type that supports it,
and ensure the bidict is left in a consistent state afterward.
"""
method = getattr(B, methodname, None)
if not method:
return
args = []
if arity == -1:
args.append(items)
else:
if arity > 0:
args.append(arg1)
if arity > 1:
args.append(arg2)
b0 = B(init)
b1 = b0.copy()
try:
method(b1, *args)
except Exception as exc: # pylint: disable=W0703
# method should fail clean, i.e. b1 should be in the same state it was before the call.
assert b1 == b0, '%r did not fail clean: %r' % (method, exc)
assert b1.inv == b0.inv, '%r did not fail clean: %r' % (method, exc)
# Whether method failed or succeeded, b1 should pass consistency checks.
assert len(b1) == sum(1 for _ in iteritems(b1))
assert len(b1) == sum(1 for _ in iteritems(b1.inv))
assert b1 == dict(iteritems(b1))
assert b1.inv == dict(iteritems(b1.inv))
assert b1 == to_inv_odict(iteritems(b1.inv))
assert b1.inv == to_inv_odict(iteritems(b1))
def test_consistency_after_mutation(arity, methodname, B, init, arg1, arg2,
items):
method = getattr(B, methodname, None)
if not method:
return
b = B(init)
args = []
if arity == -1:
args.append(items)
else:
if arity > 0:
args.append(arg1)
if arity > 1:
args.append(arg2)
b0 = b.copy()
try:
method(b, *args)
except:
# All methods should fail clean, reverting any changes made before failure.
assert b == b0
assert b.inv == b0.inv
assert b == to_inv_odict(iteritems(b.inv))
assert b.inv == to_inv_odict(iteritems(b))
ordered = issubclass(B, OrderedBidirectionalMapping)
if ordered and methodname != 'move_to_end':
items0 = viewitems(b0)
items1 = viewitems(b)
common = items0 & items1
if common:
items0 = list(items0)
items1 = list(items1)
for i in common:
idx0 = items0.index(i)
idx1 = items1.index(i)
beforei0 = [j for j in items0[:idx0] if j in common]
beforei1 = [j for j in items1[:idx1] if j in common]
assert beforei0 == beforei1
afteri0 = [j for j in items0[idx0 + 1:] if j in common]
afteri1 = [j for j in items1[idx1 + 1:] if j in common]
assert afteri0 == afteri1
def test_consistency_after_mutation(arity, methodname, B, init, arg1, arg2, items):
method = getattr(B, methodname, None)
if not method:
return
b = B(init)
args = []
if arity == -1:
args.append(items)
else:
if arity > 0:
args.append(arg1)
if arity > 1:
args.append(arg2)
b0 = b.copy()
try:
method(b, *args)
except:
# All methods should fail clean, reverting any changes made before failure.
assert b == b0
assert b.inv == b0.inv
assert b == to_inv_odict(iteritems(b.inv))
assert b.inv == to_inv_odict(iteritems(b))
ordered = issubclass(B, OrderedBidirectionalMapping)
if ordered and methodname != 'move_to_end':
items0 = viewitems(b0)
items1 = viewitems(b)
common = items0 & items1
if common:
items0 = list(items0)
items1 = list(items1)
for i in common:
idx0 = items0.index(i)
idx1 = items1.index(i)
beforei0 = [j for j in items0[:idx0] if j in common]
beforei1 = [j for j in items1[:idx1] if j in common]
assert beforei0 == beforei1
afteri0 = [j for j in items0[idx0 + 1:] if j in common]
afteri1 = [j for j in items1[idx1 + 1:] if j in common]
assert afteri0 == afteri1
def test_equality(B, init): # noqa
b = B(init)
d = dict(init)
o = OrderedDict(init)
oi = to_inv_odict(iteritems(o))
di = OrderedDict(oi)
assert b == d
assert b == o
assert not b != d
assert not b != o
assert b.inv == oi
assert b.inv == di
assert not b.inv != oi
assert not b.inv != di
def test_bijectivity(bi):
"""b[k] == v <==> b.inv[v] == k"""
for b in (bi, bi.inv):
assert all(b.inv[v] == k for (k, v) in iteritems(b))
def test_inverted_bidict(bi_and_cmp_dict):
""":func:`bidict.inverted` should yield the inverse items of a bidict."""
bi, cmp_dict = bi_and_cmp_dict
cmp_dict_inv = OrderedDict((v, k) for (k, v) in iteritems(cmp_dict))
assert set(inverted(bi)) == viewitems(cmp_dict_inv) == viewitems(bi.inv)
assert set(inverted(inverted(bi))) == viewitems(cmp_dict) == viewitems(bi.inv.inv)
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_eq_ne_hash(bi_cls, other_cls, init_items, init_unequal,
not_a_mapping):
"""Test various equality comparisons and hashes between bidicts and other objects."""
# pylint: disable=too-many-locals
some_bidict = bi_cls(init_items)
other_equal = other_cls(init_items)
other_equal_inv = getattr(
other_equal, 'inv',
OrderedDict((v, k) for (k, v) in iteritems(other_equal)))
bidict_is_ordered = isinstance(some_bidict, OrderedBidictBase)
other_is_ordered = issubclass(other_cls, (OrderedBidictBase, OrderedDict))
collection = list if bidict_is_ordered and other_is_ordered else set
both_hashable = all(
isinstance(i, c.Hashable) for i in (some_bidict, other_equal))
has_eq_order_sens = getattr(bi_cls, 'equals_order_sensitive', None)
other_unequal = other_cls(init_unequal)
other_unequal_inv = getattr(
other_unequal, 'inv',
OrderedDict((v, k) for (k, v) in iteritems(other_unequal)))
assert some_bidict == other_equal
assert not some_bidict != other_equal
assert some_bidict.inv == other_equal_inv
assert not some_bidict.inv != other_equal_inv
assert collection(iteritems(some_bidict)) == collection(
iteritems(other_equal))
assert collection(iteritems(some_bidict.inv)) == collection(
iteritems(other_equal_inv))
if both_hashable:
assert hash(some_bidict) == hash(other_equal)
if has_eq_order_sens and other_is_ordered:
assert some_bidict.equals_order_sensitive(other_equal)
assert some_bidict.inv.equals_order_sensitive(other_equal_inv)
assume(init_items != init_unequal)
other_unequal = other_cls(init_unequal)
assert not some_bidict.equals_order_sensitive(other_unequal)
other_unequal_inv = getattr(
other_unequal, 'inv',
OrderedDict((v, k) for (k, v) in iteritems(other_unequal)))
assert not some_bidict.inv.equals_order_sensitive(other_unequal_inv)
assume(set(init_items) != set(init_unequal))
assert some_bidict != other_unequal
assert not some_bidict == other_unequal
assert some_bidict.inv != other_unequal_inv
assert not some_bidict.inv == other_unequal_inv
assert collection(iteritems(some_bidict)) != collection(
iteritems(other_unequal))
assert collection(iteritems(some_bidict.inv)) != collection(
iteritems(other_unequal_inv))
assert not some_bidict == not_a_mapping
assert not some_bidict.inv == not_a_mapping
assert some_bidict != not_a_mapping
assert some_bidict.inv != not_a_mapping
if has_eq_order_sens:
assert not some_bidict.equals_order_sensitive(not_a_mapping)
assert not some_bidict.inv.equals_order_sensitive(not_a_mapping)
def test_bijectivity(bi):
"""b[k] == v <==> b.inv[v] == k"""
for b in (bi, bi.inv):
assert all(b.inv[v] == k for (k, v) in iteritems(b))
@given(init=inititems)
def test_bidirectional_mappings(B, init):
ordered = issubclass(B, OrderedBidirectionalMapping)
C = list if ordered else sorted
b = B(init)
keysf = C(k for (k, v) in iteritems(b))
keysi = C(b.inv[v] for (k, v) in iteritems(b))
assert keysf == keysi
valsf = C(b[k] for (v, k) in iteritems(b.inv))
valsi = C(v for (v, k) in iteritems(b.inv))
assert valsf == valsi
@pytest.mark.parametrize('arity,methodname',
[(a, m)
for (a, ms) in iteritems(mutating_methods_by_arity)
for m in ms])
@pytest.mark.parametrize('B', mutable_bidict_types)
@given(init=inititems, arg1=immutable, arg2=immutable, items=itemlists)
def test_consistency_after_mutation(arity, methodname, B, init, arg1, arg2,
items):
method = getattr(B, methodname, None)
if not method:
return
b = B(init)
args = []
if arity == -1:
args.append(items)
else:
if arity > 0:
args.append(arg1)
def prune_dup_vals(items):
pruned = list(iteritems(to_inv_odict(iteritems(to_inv_odict(items)))))
assume(len(pruned) >= len(items) // 2)
return pruned
def prune_dup_vals(items):
return list(iteritems(to_inv_odict(iteritems(to_inv_odict(items)))))
@pytest.mark.parametrize('B', bidict_types)
@given(init=inititems)
def test_bidirectional_mappings(B, init):
ordered = issubclass(B, OrderedBidirectionalMapping)
C = list if ordered else sorted
b = B(init)
keysf = C(k for (k, v) in iteritems(b))
keysi = C(b.inv[v] for (k, v) in iteritems(b))
assert keysf == keysi
valsf = C(b[k] for (v, k) in iteritems(b.inv))
valsi = C(v for (v, k) in iteritems(b.inv))
assert valsf == valsi
@pytest.mark.parametrize('arity,methodname',
[(a, m) for (a, ms) in iteritems(mutating_methods_by_arity) for m in ms])
@pytest.mark.parametrize('B', mutable_bidict_types)
@given(init=inititems, arg1=immutable, arg2=immutable, items=itemlists)
def test_consistency_after_mutation(arity, methodname, B, init, arg1, arg2, items):
method = getattr(B, methodname, None)
if not method:
return
b = B(init)
args = []
if arity == -1:
args.append(items)
else:
if arity > 0:
args.append(arg1)
if arity > 1:
args.append(arg2)
def ensure_no_dup(items):
"""Given some hypothesis-generated items, prune any with duplicated keys or values."""
pruned = list(iteritems(inverse_odict(iteritems(inverse_odict(items)))))
assume(len(pruned) >= len(items) // 2)
return pruned
def dedup(items):
"""Given some generated items, prune any with duplicated keys or values."""
pruned = list(iteritems(to_inv_odict(iteritems(to_inv_odict(items)))))
assume(len(pruned) >= len(items) // 2)
return pruned
def prune_dup_vals(items):
return list(iteritems(to_inv_odict(iteritems(to_inv_odict(items)))))
