def test_insert(self):
items = ItemList(str)
items.insert(0, 'a')
items.insert(0, 'b')
items.insert(3, 'c')
items.insert(1, 'd')
assert_equal(list(items), ['b', 'd', 'a', 'c'])
def test_pop(self):
items = ItemList(str, items='abcde')
assert_equal(items.pop(), 'e')
assert_equal(items.pop(0), 'a')
assert_equal(items.pop(-2), 'c')
assert_equal(list(items), ['b', 'd'])
assert_raises(IndexError, items.pop, 7)
assert_equal(list(items), ['b', 'd'])
assert_raises(IndexError, ItemList(int).pop)
def test_create_with_args_and_kwargs(self):
class Item(object):
def __init__(self, arg1, arg2):
self.arg1 = arg1
self.arg2 = arg2
items = ItemList(Item)
item = items.create('value 1', arg2='value 2')
assert_equal(item.arg1, 'value 1')
assert_equal(item.arg2, 'value 2')
assert_equal(list(items), [item])
def test_common_attrs(self):
item1 = Object()
item2 = Object()
parent = object()
items = ItemList(Object, {'attr': 2, 'parent': parent}, [item1])
items.append(item2)
assert_true(item1.parent is parent)
assert_equal(item1.attr, 2)
assert_true(item2.parent is parent)
assert_equal(item2.attr, 2)
assert_equal(list(items), [item1, item2])
def test_common_attrs(self):
item1 = Object()
item2 = Object()
parent = object()
items = ItemList(Object, {'attr': 2, 'parent': parent}, [item1])
items.append(item2)
assert_true(item1.parent is parent)
assert_equal(item1.attr, 2)
assert_true(item2.parent is parent)
assert_equal(item2.attr, 2)
assert_equal(list(items), [item1, item2])
def test_create_with_args_and_kwargs(self):
class Item(object):
def __init__(self, arg1, arg2):
self.arg1 = arg1
self.arg2 = arg2
items = ItemList(Item)
item = items.create('value 1', arg2='value 2')
assert_equal(item.arg1, 'value 1')
assert_equal(item.arg2, 'value 2')
assert_equal(list(items), [item])
def test_remove(self):
items = ItemList(str, items='abcba')
items.remove('c')
assert_equal(list(items), list('abba'))
items.remove('a')
assert_equal(list(items), list('bba'))
items.remove('b')
items.remove('a')
items.remove('b')
assert_equal(list(items), list(''))
assert_raises(ValueError, items.remove, 'nonex')
def test_index_with_start_and_stop(self):
numbers = [0, 1, 2, 3, 2, 1, 0]
items = ItemList(int, items=numbers)
for num in sorted(set(numbers)):
for start in range(len(numbers)):
if num in numbers[start:]:
assert_equal(items.index(num, start),
numbers.index(num, start))
for end in range(start, len(numbers)):
if num in numbers[start:end]:
assert_equal(items.index(num, start, end),
numbers.index(num, start, end))
def test_index_with_start_and_stop(self):
numbers = [0, 1, 2, 3, 2, 1, 0]
items = ItemList(int, items=numbers)
for num in sorted(set(numbers)):
for start in range(len(numbers)):
if num in numbers[start:]:
assert_equal(items.index(num, start),
numbers.index(num, start))
for end in range(start, len(numbers)):
if num in numbers[start:end]:
assert_equal(items.index(num, start, end),
numbers.index(num, start, end))
def test_modifications_during_reversed(self):
chars = ItemList(str, items='yxdba')
for c in reversed(chars):
if c == 'a':
chars.remove('x')
if c == 'b':
chars.insert(-2, 'c')
if c == 'c':
chars.pop(0)
if c == 'd':
chars.insert(0, 'e')
assert_true(c in 'abcde', '%s was unexpected here!' % c)
assert_equal(list(chars), list('edcba'))
def test_getitem(self):
item1 = object()
item2 = object()
items = ItemList(object, items=[item1, item2])
assert_true(items[0] is item1)
assert_true(items[1] is item2)
assert_true(items[-1] is item2)
def test_setitem_slice_is_not_supported(self):
assert_raises_with_msg(TypeError,
'ItemList instances do not support slicing.',
ItemList(int).__setitem__, slice(0), [])
assert_raises_with_msg(TypeError,
'CustomItems instances do not support slicing.',
CustomItems(int).__setitem__, slice(0), [])
def test_iter(self):
numbers = list(range(10))
items = ItemList(int, items=numbers)
assert_equal(list(items), numbers)
assert_equal(tuple(items), tuple(numbers))
for i, n in zip(items, numbers):
assert_equal(i, n)
def test_compare_incompatible(self):
assert_false(ItemList(int) == ItemList(str))
assert_false(ItemList(int) == ItemList(int, {'a': 1}))
assert_raises_with_msg(TypeError,
'Cannot order incompatible ItemLists',
ItemList(int).__gt__, ItemList(str))
assert_raises_with_msg(TypeError,
'Cannot order incompatible ItemLists',
ItemList(int).__gt__, ItemList(int, {'a': 1}))
def test_modifications_during_iter(self):
chars = ItemList(str, items='abdx')
for c in chars:
if c == 'a':
chars.pop()
if c == 'b':
chars.insert(2, 'c')
if c == 'c':
chars.append('e')
assert_true(c in 'abcde', '%s was unexpected here!' % c)
assert_equal(list(chars), list('abcde'))
def test_comparisons(self):
n123 = ItemList(int, items=[1, 2, 3])
n123b = ItemList(int, items=[1, 2, 3])
n1234 = ItemList(int, items=[1, 2, 3, 4])
n124 = ItemList(int, items=[1, 2, 4])
assert_true(n123 == n123b)
assert_false(n123 != n123b)
assert_true(n123 != n1234)
assert_false(n123 == n1234)
assert_true(n1234 > n123)
assert_true(n1234 >= n123)
assert_false(n1234 < n123)
assert_false(n1234 <= n123)
assert_true(n124 > n123)
assert_true(n124 >= n123)
assert_false(n124 < n123)
assert_false(n124 <= n123)
assert_true(n123 >= n123)
assert_true(n123 <= n123)
def test_delitem_slice(self):
items = ItemList(str, items='abcde')
del items[1:3]
assert_equal(list(items), list('ade'))
del items[2:]
assert_equal(list(items), list('ad'))
del items[10:]
assert_equal(list(items), list('ad'))
del items[:]
assert_equal(list(items), [])
def test_delitem(self):
items = ItemList(str, items='abcde')
del items[0]
assert_equal(list(items), list('bcde'))
del items[1]
assert_equal(list(items), list('bde'))
del items[-1]
assert_equal(list(items), list('bd'))
assert_raises(IndexError, items.__delitem__, 10)
assert_equal(list(items), list('bd'))
def test_setitem_slice(self):
items = ItemList(int, items=range(10))
items[:5] = []
items[-2:] = [42]
assert_equal(list(items), [5, 6, 7, 42])
items = CustomItems(Object, {'a': 1}, [Object(i) for i in range(10)])
items[1::3] = tuple(Object(c) for c in 'abc')
assert_true(all(obj.a == 1 for obj in items))
assert_equal([obj.id for obj in items],
[0, 'a', 2, 3, 'b', 5, 6, 'c', 8, 9])
def test_setitem(self):
orig1, orig2 = Object(), Object()
new1, new2 = Object(), Object()
items = ItemList(Object, {'attr': 2}, [orig1, orig2])
items[0] = new1
assert_equal(list(items), [new1, orig2])
assert_equal(new1.attr, 2)
items[-1] = new2
assert_equal(list(items), [new1, new2])
assert_equal(new2.attr, 2)
def test_insert(self):
items = ItemList(str)
items.insert(0, 'a')
items.insert(0, 'b')
items.insert(3, 'c')
items.insert(1, 'd')
assert_equal(list(items), ['b', 'd', 'a', 'c'])
def test_comparisons_with_other_objects(self):
items = ItemList(int, items=[1, 2, 3])
assert_false(items == 123)
assert_false(items == [1, 2, 3])
assert_false(items == (1, 2, 3))
assert_true(items != 123)
assert_true(items != [1, 2, 3])
assert_true(items != (1, 2, 3))
assert_raises_with_msg(TypeError, 'Cannot order ItemList and int',
items.__gt__, 1)
assert_raises_with_msg(TypeError, 'Cannot order ItemList and list',
items.__lt__, [1, 2, 3])
assert_raises_with_msg(TypeError, 'Cannot order ItemList and tuple',
items.__ge__, (1, 2, 3))
def test_pop(self):
items = ItemList(str, items='abcde')
assert_equal(items.pop(), 'e')
assert_equal(items.pop(0), 'a')
assert_equal(items.pop(-2), 'c')
assert_equal(list(items), ['b', 'd'])
assert_raises(IndexError, items.pop, 7)
assert_equal(list(items), ['b', 'd'])
assert_raises(IndexError, ItemList(int).pop)
def test_getitem_slice(self):
items = ItemList(int, items=range(10))
sub = items[:5]
assert_true(isinstance(sub, ItemList))
assert_equal(list(sub), range(0, 5))
assert_equal(list(items), range(10))
sub.append(5)
assert_equal(list(sub), range(0, 6))
assert_equal(list(items), range(10))
backwards = items[::-1]
assert_true(isinstance(backwards, ItemList))
assert_equal(list(backwards), list(reversed(items)))
empty = items[100:]
assert_true(isinstance(empty, ItemList))
assert_equal(list(empty), [])
def test_create_items(self):
items = ItemList(str)
item = items.create(object=1)
assert_true(isinstance(item, str))
assert_equal(item, '1')
assert_equal(list(items), [item])
def test_index(self):
items = ItemList(str, items=('first', 'second'))
assert_equal(items.index('first'), 0)
assert_equal(items.index('second'), 1)
assert_raises(ValueError, items.index, 'nonex')
def test_truth(self):
assert_true(not ItemList(int))
assert_true(ItemList(int, items=[1]))
def test_extend_with_generator(self):
items = ItemList(str)
items.extend((c for c in 'Hello, world!'))
assert_equal(list(items), list('Hello, world!'))
def test_append_and_extend(self):
items = ItemList(int)
items.append(1)
items.append(2)
items.extend((3, 4))
assert_equal(list(items), [1, 2, 3, 4])
def test_index(self):
items = ItemList(str, items=('first', 'second'))
assert_equal(items.index('first'), 0)
assert_equal(items.index('second'), 1)
def test_str(self):
assert_equal(str(ItemList(str, items=['foo', 'bar', 'quux'])),
'[foo, bar, quux]')
def test_append_and_extend(self):
items = ItemList(int)
items.append(1)
items.append(2)
items.extend((3, 4))
assert_equal(list(items), [1, 2, 3, 4])
def test_index(self):
items = ItemList(str, items=('first', 'second'))
assert_equal(items.index('first'), 0)
assert_equal(items.index('second'), 1)
def test_only_matching_types_can_be_added(self):
assert_raises(TypeError, ItemList(int).append, 'not integer')
def test_index(self):
items = ItemList(str, items=('first', 'second'))
assert_equal(items.index('first'), 0)
assert_equal(items.index('second'), 1)
assert_raises(ValueError, items.index, 'nonex')
def test_getitem_slice_is_not_supported(self):
assert_raises(TypeError, ItemList(int).__getitem__, slice(0))
def test_create_items(self):
items = ItemList(str)
item = items.create(object=1)
assert_true(isinstance(item, str))
assert_equal(item, '1')
assert_equal(list(items), [item])
def test_len(self):
items = ItemList(object)
assert_equal(len(items), 0)
items.create()
assert_equal(len(items), 1)
def test_index(self):
items = ItemList(str, items=("first", "second"))
assert_equal(items.index("first"), 0)
assert_equal(items.index("second"), 1)
def test_clear(self):
items = ItemList(int, range(10))
items.clear()
assert_equal(len(items), 0)
def test_len(self):
items = ItemList(object)
assert_equal(len(items), 0)
items.create()
assert_equal(len(items), 1)
def test_unicode(self):
assert_equal(unicode(ItemList(int, items=[1, 2, 3, 4])),
'[1, 2, 3, 4]')
assert_equal(unicode(ItemList(unicode, items=[u'hyv\xe4\xe4', u'y\xf6'])),
u'[hyv\xe4\xe4, y\xf6]')
def test_clear(self):
items = ItemList(int, range(10))
items.clear()
assert_equal(len(items), 0)
