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 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 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_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)))