def test_common(self):
try:
from collections import Counter
except ImportError:
# Python 2.6
from python_toolbox.third_party.collections import Counter
bag = self.bag_type('abracadabra')
if not issubclass(self.bag_type, nifty_collections.Ordered):
assert bag == Counter('abracadabra') == Counter(bag) == \
self.bag_type(Counter('abracadabra'))
assert len(bag) == 5
assert set(bag) == set(bag.keys()) == set('abracadabra')
assert set(bag.values()) == set((1, 2, 5))
assert set(bag.items()) == \
set((('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)))
assert bag['a'] == 5
assert bag['missing value'] == 0
assert len(bag) == 5
assert 'a' in bag
assert 'r' in bag
assert 'R' not in bag
assert 'x' not in self.bag_type({
'x': 0,
})
assert bag != 7
assert set(bag.most_common()) == set(bag.most_common(len(bag))) == \
set(Counter(bag).most_common()) == \
set(Counter(bag.elements).most_common())
assert bag.most_common(1) == (('a', 5), )
assert set(bag.most_common(3)) == set((('a', 5), ('b', 2), ('r', 2)))
assert bag + bag == self.bag_type('abracadabra' * 2)
assert bag - bag == self.bag_type()
assert bag - self.bag_type('a') == self.bag_type('abracadabr')
assert bag - self.bag_type('a') == self.bag_type('abracadabr')
assert bag | self.bag_type('a') == bag
assert bag | bag == bag | bag | bag == bag
assert bag & self.bag_type('a') == self.bag_type('a')
assert bag & bag == \
bag & bag & bag == bag
assert self.bag_type(bag.elements) == bag
with cute_testing.RaiseAssertor(TypeError):
+bag
with cute_testing.RaiseAssertor(TypeError):
-bag
assert re.match('^(Frozen)?(Ordered)?Bag\(.*$', repr(bag))
assert bag.copy() == bag
assert pickle.loads(pickle.dumps(bag)) == bag
assert self.bag_type({'a': 0, 'b': 1,}) == \
self.bag_type({'c': 0, 'b': 1,})
def test_directly_on_object():
class A(EqualByIdentity):
def woof(self):
return (self, 'woof')
a0 = A()
a1 = A()
@monkeypatching_tools.monkeypatch(a0)
def meow(a):
return 'not meow'
@monkeypatching_tools.monkeypatch(a0)
def woof(a):
return 'not woof'
assert a0.meow() == 'not meow'
assert a0.woof() == 'not woof'
assert a1.woof() == (a1, 'woof')
with cute_testing.RaiseAssertor(AttributeError):
A.meow()
with cute_testing.RaiseAssertor(AttributeError):
a1.meow()
assert A.woof(a0) == (a0, 'woof')
def test_chain_spaces():
chain_space = ChainSpace((range(3), 'meow', range(22, 19, -1)))
assert tuple(chain_space) == (0, 1, 2, 'm', 'e', 'o', 'w', 22, 21, 20)
assert len(chain_space) == chain_space.length == 10
assert bool(chain_space) is True
for i, item in enumerate(chain_space):
assert chain_space[i] == item
assert chain_space.index(item) == i
assert chain_space == chain_space
assert 0 in chain_space
assert 'm' in chain_space
assert [] not in chain_space
with cute_testing.RaiseAssertor(ValueError):
chain_space.index('nope')
with cute_testing.RaiseAssertor(IndexError):
chain_space[-11]
with cute_testing.RaiseAssertor(IndexError):
chain_space[-110]
with cute_testing.RaiseAssertor(IndexError):
chain_space[11]
with cute_testing.RaiseAssertor(IndexError):
chain_space[1100]
assert chain_space[-1] == 20
assert chain_space[-2] == 21
assert chain_space[-10] == 0
assert not ChainSpace(())
def test_move_to_end(self):
# Overridden in test cases for bag types where it's implemented.
bag = self.bag_type('aaabbc')
with cute_testing.RaiseAssertor(AttributeError):
bag.move_to_end('c')
with cute_testing.RaiseAssertor(AttributeError):
bag.move_to_end('x', last=False)
def test_negative():
with cute_testing.RaiseAssertor(NotImplementedError):
convert_to_base_in_tuple(-1, 7)
with cute_testing.RaiseAssertor(NotImplementedError):
convert_to_base_in_tuple(-13462, 4)
with cute_testing.RaiseAssertor(NotImplementedError):
convert_to_base_in_tuple(-23451759010224, 11)
def test_dapplied_perm_space():
dapplied_perm_space = PermSpace(5, domain='growl')
assert dapplied_perm_space.is_dapplied
assert not dapplied_perm_space.is_rapplied
assert not dapplied_perm_space.is_fixed
assert not dapplied_perm_space.is_sliced
assert (0, 4, 2, 3, 1) in dapplied_perm_space
assert (0, 4, 'ooga booga', 2, 3, 1) not in dapplied_perm_space
assert dapplied_perm_space.get_partialled(3)[2] not in dapplied_perm_space
assert dapplied_perm_space.undapplied[7] not in dapplied_perm_space
dapplied_perm = dapplied_perm_space[-1]
assert dapplied_perm in dapplied_perm_space
assert isinstance(reversed(dapplied_perm), Perm)
assert reversed(dapplied_perm) in dapplied_perm_space
assert tuple(reversed(dapplied_perm)) == \
tuple(reversed(tuple(dapplied_perm)))
assert reversed(reversed(dapplied_perm)) == dapplied_perm
assert dapplied_perm['l'] == 0
assert dapplied_perm['w'] == 1
assert dapplied_perm['o'] == 2
assert dapplied_perm['r'] == 3
assert dapplied_perm['g'] == 4
assert repr(dapplied_perm) == \
'''<Perm: ('g', 'r', 'o', 'w', 'l') => (4, 3, 2, 1, 0)>'''
assert dapplied_perm.index(4) == 'g'
assert dapplied_perm.as_dictoid['g'] == 4
assert dapplied_perm.items[0] == ('g', 4)
with cute_testing.RaiseAssertor(IndexError):
dapplied_perm[2]
with cute_testing.RaiseAssertor(IndexError):
dapplied_perm.as_dictoid[2]
with cute_testing.RaiseAssertor(ValueError):
dapplied_perm.index('x')
# `__contains__` works on the values, not the keys:
for char in 'growl':
assert char not in dapplied_perm
for number in range(5):
assert number in dapplied_perm
assert not dapplied_perm_space._just_fixed.is_fixed
assert not dapplied_perm_space._just_fixed.is_dapplied
assert not dapplied_perm_space._just_fixed.is_rapplied
assert not dapplied_perm_space._just_fixed.is_partial
assert not dapplied_perm_space._just_fixed.is_combination
assert not dapplied_perm_space._just_fixed.is_degreed
assert repr(dapplied_perm_space) == "<PermSpace: 'growl' => 0..4>"
# Testing `repr` shortening:
assert repr(PermSpace(20, domain=tuple(range(19, -1, -1)))) == (
'<PermSpace: (19, 18, 17, 16, 15, 14, 13, 12, 11 ... ) => 0..19>'
)
def test():
assert dict_tools.reverse({'one': 1, 'two': 2, 'three': 3}) == \
{1: 'one', 2: 'two', 3: 'three'}
assert dict_tools.reverse({}) == {}
with cute_testing.RaiseAssertor():
dict_tools.reverse({1: 0, 2: 0})
with cute_testing.RaiseAssertor():
dict_tools.reverse({1: []})
def test_index(self):
bag = self.bag_type('aaabbc')
if not isinstance(bag, collections.Hashable):
bag['d'] = 0
with cute_testing.RaiseAssertor(AttributeError):
bag.index('a')
with cute_testing.RaiseAssertor(AttributeError):
bag.index('x')
def test():
class A(object):
y = 'y'
def __init__(self):
self.x = 'x'
self.obj = Object()
self.obj.z = 'z'
self.uuid = uuid.uuid4()
x_proxy = ProxyProperty('.x')
y_proxy = ProxyProperty(
'.y',
doc='Proxy for `y`.'
)
z_proxy = ProxyProperty('.obj.z', doc='aye, this my favorite z.')
uuid_proxy = ProxyProperty(
'.uuid',
'Object-specific UUID.'
)
nonexistant_proxy = ProxyProperty('.whatevs')
assert isinstance(A.x_proxy, ProxyProperty)
assert isinstance(A.y_proxy, ProxyProperty)
assert isinstance(A.z_proxy, ProxyProperty)
assert isinstance(A.uuid_proxy, ProxyProperty)
assert isinstance(A.nonexistant_proxy, ProxyProperty)
a0 = A()
a1 = A()
assert a0.x_proxy == a1.x_proxy == 'x'
assert a0.y_proxy == a1.y_proxy == 'y'
assert a0.z_proxy == a1.z_proxy == 'z'
assert isinstance(a0.uuid_proxy, uuid.UUID)
assert isinstance(a1.uuid_proxy, uuid.UUID)
assert a0.uuid == a0.uuid_proxy != a1.uuid_proxy == a1.uuid
with cute_testing.RaiseAssertor(AttributeError):
a0.nonexistant_proxy
with cute_testing.RaiseAssertor(AttributeError):
a1.nonexistant_proxy
### Setting proxy-properties to different values: #########################
# #
a0.x_proxy = 7
assert a0.x_proxy == 7 != a1.x_proxy == 'x'
a0.y_proxy = 'meow'
assert a0.y_proxy == 'meow' != a1.y_proxy == 'y'
a0.z_proxy = [1, 2, 3]
assert a0.z_proxy == [1, 2, 3] != a1.z_proxy == 'z'
# #
### Finished setting proxy-properties to different values. ################
assert repr(A.x_proxy) == '''<ProxyProperty: '.x'>'''
assert repr(A.z_proxy) == ('''<ProxyProperty: '.obj.z', doc='aye, this '''
'''my favorite z.'>''')
def test():
assert decimal_number_from_string('7') == 7
assert type(decimal_number_from_string('7')) == int
assert decimal_number_from_string('-12.34') == -12.34
assert type(decimal_number_from_string('-12.34')) == float
with cute_testing.RaiseAssertor():
decimal_number_from_string(31412)
with cute_testing.RaiseAssertor():
decimal_number_from_string('JJfa')
def test_hash(self):
bag = self.bag_type('abracadabra')
assert not isinstance(bag, collections.Hashable)
assert not issubclass(self.bag_type, collections.Hashable)
with cute_testing.RaiseAssertor(TypeError):
{bag}
with cute_testing.RaiseAssertor(TypeError):
{bag: None,}
with cute_testing.RaiseAssertor(TypeError):
hash(bag)
def test_index(self):
bag = self.bag_type('aaabbc')
if not isinstance(bag, collections.Hashable):
bag['d'] = 0
assert bag.index('a') == 0
assert bag.index('b') == 1
assert bag.index('c') == 2
with cute_testing.RaiseAssertor(ValueError):
bag.index('d')
with cute_testing.RaiseAssertor(ValueError):
bag.index('x')
with cute_testing.RaiseAssertor(ValueError):
bag.index(('meow', ))
def test_move_to_end(self):
bag = self.bag_type('aaabbc')
bag.move_to_end('c')
assert FrozenOrderedBag(bag) == FrozenOrderedBag('aaabbc')
bag.move_to_end('a')
assert FrozenOrderedBag(bag) == FrozenOrderedBag('bbcaaa')
bag.move_to_end('c', last=False)
assert FrozenOrderedBag(bag) == FrozenOrderedBag('cbbaaa')
with cute_testing.RaiseAssertor(KeyError):
bag.move_to_end('x')
with cute_testing.RaiseAssertor(KeyError):
bag.move_to_end('x', last=False)
def test_illegal_cases():
illegal_cases = ((4, 0), (infinity, 0), (-infinity, 0))
for illegal_case in illegal_cases:
with cute_testing.RaiseAssertor() as raise_assertor_0:
cute_divmod(*illegal_case)
with cute_testing.RaiseAssertor() as raise_assertor_1:
divmod(*illegal_case)
with cute_testing.RaiseAssertor() as raise_assertor_2:
cute_floor_div(*illegal_case)
assert logic_tools.all_equivalent((
type(raise_assertor_0.exception),
type(raise_assertor_1.exception),
type(raise_assertor_2.exception),
))
def test():
huge_perm_space = PermSpace(range(100))
big_perm_space = PermSpace(range(150),
fixed_map={
1: 5,
70: 3,
},
degrees=(3, 5))
product_space = ProductSpace((huge_perm_space, big_perm_space))
assert product_space.length == \
huge_perm_space.length * big_perm_space.length
(perm_0, perm_1) = product_space[10**10]
assert perm_0 in huge_perm_space
assert perm_1 in big_perm_space
assert (perm_0, perm_1) in product_space
assert product_space.index((perm_0, perm_1)) == 10**10
repr(~perm_0)
repr(~perm_1)
assert (~perm_0, ~perm_1) in product_space
assert repr(product_space) == (
'<ProductSpace: 933262154439441526816992388562667004907159682643816214'
'685929638952175999932299156089414639761565182862536979208272237582511'
'85210916864000000000000000000000000 * 208755412068>')
assert product_space
assert not ProductSpace(((), ))
assert not ProductSpace(((), {}))
with cute_testing.RaiseAssertor(IndexError):
product_space[product_space.length]
with cute_testing.RaiseAssertor(IndexError):
product_space[product_space.length + 7]
with cute_testing.RaiseAssertor(IndexError):
product_space[-product_space.length - 1]
with cute_testing.RaiseAssertor(IndexError):
product_space[-product_space.length - 100]
assert {
ProductSpace((range(4), range(3))),
ProductSpace((range(4), range(3))),
ProductSpace((range(3), range(4)))
} == {
ProductSpace((range(4), range(3))),
ProductSpace((range(3), range(4)))
}
assert ProductSpace((range(4), range(3))) == \
ProductSpace((range(4), range(3)))
assert ProductSpace((range(4), range(3))) != \
ProductSpace((range(3), range(4)))
def test():
frozen_ordered_dict = \
FrozenOrderedDict((('1', 'a'), ('2', 'b'), ('3', 'c')))
assert len(frozen_ordered_dict) == 3
assert set(frozen_ordered_dict) == set(frozen_ordered_dict.keys()) == \
set('123')
assert set(frozen_ordered_dict.values()) == set('abc')
assert set(frozen_ordered_dict.items()) == \
set((('1', 'a'), ('2', 'b'), ('3', 'c'),))
assert frozen_ordered_dict['1'] == 'a'
with cute_testing.RaiseAssertor(exception_type=LookupError):
frozen_ordered_dict['missing value']
assert set((frozen_ordered_dict, frozen_ordered_dict)) == \
set((frozen_ordered_dict,))
assert {frozen_ordered_dict: frozen_ordered_dict} == \
{frozen_ordered_dict: frozen_ordered_dict}
assert isinstance(hash(frozen_ordered_dict), int)
assert frozen_ordered_dict.copy({'meow': 'frrr'}) == \
frozen_ordered_dict.copy(meow='frrr') == \
FrozenOrderedDict((('1', 'a'), ('2', 'b'), ('3', 'c'),
('meow', 'frrr')))
assert repr(frozen_ordered_dict).startswith('FrozenOrderedDict(')
assert pickle.loads(pickle.dumps(frozen_ordered_dict)) == \
frozen_ordered_dict
def test():
def f1(alpha, beta, gamma=10, delta=20, *args, **kwargs):
return (alpha, beta, args, gamma, delta, kwargs)
assert f1(1, 2) == (1, 2, (), 10, 20, {})
monkeypatching_tools.change_defaults(f1, {'delta': 200,})
assert f1(1, 2) == (1, 2, (), 10, 200, {})
@monkeypatching_tools.change_defaults({'gamma': 100})
def f2(alpha, beta, gamma=10, delta=20, *args, **kwargs):
return (alpha, beta, args, gamma, delta, kwargs)
assert f2(1, 2) == (1, 2, (), 100, 20, {})
@monkeypatching_tools.change_defaults(new_defaults={'gamma': 1000})
def f3(alpha, beta, gamma=10, delta=20, *args, **kwargs):
return (alpha, beta, args, gamma, delta, kwargs)
assert f3(1, 2) == (1, 2, (), 1000, 20, {})
@monkeypatching_tools.change_defaults(new_defaults={'x': 'A', 'z': 'C'})
def f4(x='a', y='b', z='c'):
return (x, y, z)
assert f4() == ('A', 'b', 'C')
with cute_testing.RaiseAssertor(Exception):
@monkeypatching_tools.change_defaults(new_defaults={'x': 'A', 'z': 'C',
'nonexistant': 7,})
def f5(x='a', y='b', z='c'):
return (x, y, z)
def test():
frozen_dict = FrozenDict({
'1': 'a',
'2': 'b',
'3': 'c',
})
assert len(frozen_dict) == 3
assert set(frozen_dict) == set(frozen_dict.keys()) == \
set(frozen_dict.iterkeys()) == set('123')
assert set(frozen_dict.values()) == \
set(frozen_dict.itervalues()) == set('abc')
assert set(frozen_dict.items()) == \
set(frozen_dict.iteritems()) == {('1', 'a'), ('2', 'b'), ('3', 'c'),}
assert frozen_dict['1'] == 'a'
with cute_testing.RaiseAssertor(exception_type=LookupError):
frozen_dict['missing value']
assert {frozen_dict, frozen_dict} == {frozen_dict}
assert {frozen_dict: frozen_dict} == {frozen_dict: frozen_dict}
assert isinstance(hash(frozen_dict), int)
assert frozen_dict.copy({'meow': 'frrr'}) == \
frozen_dict.copy(meow='frrr') == \
FrozenDict({'1': 'a', '2': 'b', '3': 'c', 'meow': 'frrr',})
assert repr(frozen_dict).startswith('FrozenDict(')
def test_mutable(self):
ordered_set = self.ordered_set_type(range(4))
assert list(ordered_set) == list(range(4))
assert len(ordered_set) == 4
assert 1 in ordered_set
assert 3 in ordered_set
assert 7 not in ordered_set
ordered_set.add(8)
assert list(ordered_set)[-1] == 8
ordered_set.discard(2)
assert 2 not in ordered_set
assert list(reversed(ordered_set)) == [8, 3, 1, 0]
assert ordered_set.pop() == 8
assert ordered_set.pop(last=False) == 0
ordered_set.add(7, last=False)
assert tuple(ordered_set) == (7, 1, 3)
with cute_testing.RaiseAssertor(KeyError):
ordered_set.remove('meow')
ordered_set.discard('meow')
ordered_set.discard('meow')
ordered_set.discard('meow')
assert ordered_set | ordered_set == ordered_set
assert ordered_set & ordered_set == ordered_set
def test_larger_on_remainder():
r = list(range(9))
assert partitions(r, 1, larger_on_remainder=True) == \
partitions(r, n_partitions=9, larger_on_remainder=True) == \
[[0], [1], [2], [3], [4], [5], [6], [7], [8]]
assert partitions(r, 2, larger_on_remainder=True) == \
partitions(r, n_partitions=4, larger_on_remainder=True) == \
partitions(r, n_partitions=4, larger_on_remainder=True,
fill_value='gurr') == \
[[0, 1], [2, 3], [4, 5], [6, 7, 8]]
assert partitions(r, 3, larger_on_remainder=True) == \
partitions(r, n_partitions=3, larger_on_remainder=True,
fill_value='gurr') == \
[[0, 1, 2], [3, 4, 5], [6, 7, 8]]
assert partitions(tuple(r), 4, larger_on_remainder=True) == \
[(0, 1, 2, 3), (4, 5, 6, 7, 8)]
assert partitions(tuple(r), n_partitions=3, larger_on_remainder=True) == \
[(0, 1, 2), (3, 4, 5), (6, 7, 8)]
assert partitions([1], 1, larger_on_remainder=True) == \
partitions([1], 2, larger_on_remainder=True) == \
partitions([1], n_partitions=1, larger_on_remainder=True) == \
partitions([1], 3, larger_on_remainder=True) == \
partitions([1], 4, larger_on_remainder=True) == \
partitions([1], 1000, larger_on_remainder=True) == \
partitions([1], 1000, larger_on_remainder=True, fill_value='meow') == \
[[1]]
with cute_testing.RaiseAssertor(text='remainder of 1'):
partitions([1], 1000, larger_on_remainder=True, allow_remainder=False,
fill_value='meow')
def test_garbage_collection():
garbage_collected = set()
class GarbageNoter(object):
def __init__(self, n):
assert isinstance(n, int)
self.n = n
def __del__(self):
garbage_collected.add(self.n)
iterable = (GarbageNoter(i) for i in xrange(7))
consecutive_subsequences_iterator = \
iterate_overlapping_subsequences(iterable, length=3)
def assert_garbage_collected(indexes):
gc_tools.collect()
assert set(indexes) == garbage_collected
assert_garbage_collected(())
next(consecutive_subsequences_iterator)
assert_garbage_collected(())
next(consecutive_subsequences_iterator)
assert_garbage_collected((0, ))
next(consecutive_subsequences_iterator)
assert_garbage_collected((0, 1))
next(consecutive_subsequences_iterator)
assert_garbage_collected((0, 1, 2))
next(consecutive_subsequences_iterator)
assert_garbage_collected((0, 1, 2, 3))
with cute_testing.RaiseAssertor(StopIteration):
next(consecutive_subsequences_iterator)
assert_garbage_collected((0, 1, 2, 3, 4, 5, 6))
def test():
comb_space = CombSpace('dumber', 2)
assert isinstance(comb_space, CombSpace)
assert isinstance(comb_space, PermSpace)
assert comb_space.length == 1 + 2 + 3 + 4 + 5
things_in_comb_space = ('du', 'db', 'br', ('d', 'u'),
Comb('du', comb_space))
things_not_in_comb_space = ('dx', 'dub', ('d', 'x'), set(
('d', 'u', 'b')), Comb('dux',
comb_space), Comb('du', CombSpace('other', 2)),
set(('d', 'u')), 'ud', 'rb',
Comb('bu', comb_space))
for thing in things_in_comb_space:
assert thing in comb_space
for thing in things_not_in_comb_space:
assert thing not in comb_space
assert comb_space.n_unused_elements == 4
assert comb_space.index('du') == 0
assert comb_space.index('er') == comb_space.length - 1
assert comb_space.undapplied == comb_space
assert comb_space.unrapplied == CombSpace(6, 2)
assert comb_space.unpartialled == CombSpace('dumber', 6)
assert comb_space.unpartialled.get_partialled(5) == CombSpace('dumber', 5)
assert comb_space.uncombinationed == PermSpace('dumber', n_elements=2)
assert comb_space.undegreed == comb_space
assert comb_space.unrapplied.get_rapplied(range(10, 70, 10)) == \
CombSpace(range(10, 70, 10), 2)
with cute_testing.RaiseAssertor():
comb_space.undapplied.get_dapplied(range(10, 70, 10))
with cute_testing.RaiseAssertor():
comb_space.get_degreed(3)
assert comb_space.unfixed == comb_space
assert not comb_space.fixed_indices
assert comb_space.free_indices == comb_space.free_keys == \
sequence_tools.CuteRange(2)
assert comb_space.free_values == 'dumber'
comb = comb_space[7]
assert type(comb.uncombinationed) is Perm
assert tuple(comb) == tuple(comb.uncombinationed)
assert comb.is_combination
assert not comb.uncombinationed.is_combination
assert repr(comb_space) == '''<CombSpace: 'dumber', n_elements=2>'''
assert repr(CombSpace(tuple(range(50, 0, -1)), 3)) == \
'''<CombSpace: (50, 49, 48, 47, 46, 45, 44, 43, 42 ... ), n_elements=3>'''
def test_get_single_if_any():
assert get_single_if_any(()) is get_single_if_any([]) is \
get_single_if_any({}) is get_single_if_any(iter({})) is \
get_single_if_any('') is None
assert get_single_if_any(('g',)) == get_single_if_any(['g']) == \
get_single_if_any({'g'}) == get_single_if_any(iter({'g'})) == \
get_single_if_any('g') == 'g'
with cute_testing.RaiseAssertor():
get_single_if_any(('g', 'e', 'e'))
with cute_testing.RaiseAssertor():
get_single_if_any('gee')
assert get_single_if_any('gee', exception_on_multiple=None) == 'g'
def test_illegal():
illegal_range_arguments_tuples = (
(infinity, 10, -7),
)
for illegal_range_arguments_tuple in illegal_range_arguments_tuples:
with cute_testing.RaiseAssertor(TypeError):
CuteRange(*illegal_range_arguments_tuple)
def test_pushback_iterator():
pushback_iterator = PushbackIterator(iter([1, 2, 3]))
assert next(pushback_iterator) == 1
assert next(pushback_iterator) == 2
pushback_iterator.push_back()
assert next(pushback_iterator) == 2
assert next(pushback_iterator) == 3
pushback_iterator.push_back()
assert next(pushback_iterator) == 3
with cute_testing.RaiseAssertor(StopIteration):
next(pushback_iterator)
pushback_iterator.push_back()
assert next(pushback_iterator) == 3
with cute_testing.RaiseAssertor(StopIteration):
next(pushback_iterator)
def test_exception():
my_freezer = MyFreezer()
with cute_testing.RaiseAssertor(MyException):
assert not my_freezer.frozen
assert my_freezer.freeze_counter == my_freezer.thaw_counter == 0
with my_freezer:
raise MyException
assert my_freezer.freeze_counter == my_freezer.thaw_counter == 1
def test_too_many_arguments():
'''Test helpful error when giving both `item_type` and `item_test`.'''
with cute_testing.RaiseAssertor(text='either'):
to_tuple(
(1, 2, 3),
item_type=int,
item_test=lambda item: isinstance(item, int)
)
def _check_helpful_warnings_for_old_protocols(pickle_module,
cross_process_persistent,
old_protocol):
'''
Test that helpful errors are given when trying to pickle with old protocol.
'''
assert old_protocol < 2
with cute_testing.RaiseAssertor(text=('protocol %s' % old_protocol)):
pickle_module.dumps(cross_process_persistent, protocol=old_protocol)
def test_fill_value():
'''Test `fill_value` keyword arguemnt for `partitions`.'''
r = range(5)
assert partitions(r, 3) == [[0, 1, 2], [3, 4]]
assert partitions(r, 3, fill_value=None) == [[0, 1, 2], [3, 4, None]]
with cute_testing.RaiseAssertor(text='fill_value'):
partitions(r, 2, fill_value=None, allow_remainder=False)
assert partitions([], 3, fill_value=None) == []
def test_comparison(self):
bag_0 = self.bag_type('c')
bag_1 = self.bag_type('abc')
bag_2 = self.bag_type('aabc')
bag_3 = self.bag_type('abbc')
bag_4 = self.bag_type('aabbcc')
not_a_bag = {}
hierarchy = (
(bag_4, [bag_3, bag_2, bag_1, bag_0]),
(bag_3, [bag_1, bag_0]),
(bag_2, [bag_1, bag_0]),
(bag_1, [bag_0]),
(bag_0, []),
)
for item, smaller_items in hierarchy:
if not isinstance(item, self.bag_type):
continue
for smaller_item in smaller_items:
assert not item <= smaller_item
assert not item < smaller_item
assert item >= smaller_item
assert item > smaller_item
assert item != smaller_item
assert smaller_item <= item
assert smaller_item < item
assert not smaller_item >= item
assert not smaller_item > item
assert smaller_item != item
not_smaller_items = [
item for item in next(zip(*hierarchy))
if item not in smaller_items
]
for not_smaller_item in not_smaller_items:
assert not item < smaller_item
with cute_testing.RaiseAssertor(TypeError):
item <= not_a_bag
with cute_testing.RaiseAssertor(TypeError):
item < not_a_bag
with cute_testing.RaiseAssertor(TypeError):
item > not_a_bag
with cute_testing.RaiseAssertor(TypeError):
item >= not_a_bag
with cute_testing.RaiseAssertor(TypeError):
not_a_bag <= item
with cute_testing.RaiseAssertor(TypeError):
not_a_bag < item
with cute_testing.RaiseAssertor(TypeError):
not_a_bag > item
with cute_testing.RaiseAssertor(TypeError):
not_a_bag >= item
