def test_totally_different(self):
a = iterlist.IterList(range(3))
b = iterlist.IterList(range(3, 10))
self.assertFalse(a == b)
self.assertEqual(len(a._list), 1)
self.assertEqual(len(b._list), 1)
self.assertTrue(a != b)
def test_with_str(self):
a = "this is a test"
b = iterlist.IterList(a)
self.assertTrue(a != b)
self.assertFalse(a == b)
self.assertTrue(list(a) == b)
self.assertFalse(list(a) != b)
def test_iter_partial_consumed(self):
orig = list(range(range_size))
lazy = iterlist.IterList(orig)
lazy[2]
self.assertEqual(len(lazy._list), 3)
for ix, v in enumerate(lazy):
self.assertEqual(v, orig[ix])
def test_for_true_already_consumed(self):
lazy = iterlist.IterList(range(2))
self.assertEqual(len(lazy._list), 0)
lazy[0]
self.assertEqual(len(lazy._list), 1)
self.assertTrue(lazy)
self.assertEqual(len(lazy._list), 1)
def test_slice_reversed_by_1(self):
orig = list(range(range_size))
lazy = iterlist.IterList(orig)
neg_slz = lazy[half_range:0:-1]
self.assertEqual(neg_slz, orig[half_range:0:-1])
self.assertEqual(len(neg_slz), half_range)
self.assertEqual(len(lazy._list), half_range + 1)
def test_negative_slice_assign(self):
lazy = iterlist.IterList(range(range_size))
seq = list(range(range_size))
lazy[-2:-5] = [10, 20, 30, 40, 50, 60]
seq[-2:-5] = [10, 20, 30, 40, 50, 60]
for i, e in enumerate(seq):
self.assertEqual(lazy[i], e)
def test_incremental(self):
lazy = iterlist.IterList(range(range_size))
for i in range(range_size):
lazy[i]
self.assertEqual(len(lazy._list), i + 1)
self.assertEqual(len(lazy), range_size)
for a, b in zip(lazy._list, range(range_size)):
self.assertEqual(a, b)
def test_slice_reversed_by_2(self):
orig = list(range(range_size))
lazy = iterlist.IterList(orig)
exp_size = int(math.floor((half_range + 1) / 2))
neg_slz = lazy[half_range::-2]
self.assertEqual(neg_slz, orig[half_range::-2])
self.assertEqual(len(neg_slz), exp_size)
self.assertEqual(len(lazy._list), half_range + 1)
def test_slice_empty_case(self):
lazy = iterlist.IterList(range(range_size))
empty_slz = lazy[0:half_range:-1]
self.assertEqual(empty_slz, [])
self.assertEqual(len(lazy._list), 0)
empty_slz2 = lazy[half_range:0]
self.assertEqual(empty_slz2, [])
self.assertEqual(len(lazy._list), 0)
def test_iter_consume_while_iter(self):
orig = list(range(range_size))
lazy = iterlist.IterList(orig)
for ix, v in enumerate(lazy):
if ix == 3:
lazy[5]
self.assertEqual(len(lazy._list), 6)
self.assertEqual(v, orig[ix])
def test_with_bare_iterable_different_length(self):
a = iterlist.IterList(range(range_size))
b = (v for v in range(range_size + 1))
self.assertFalse(a == b)
self.assertTrue(a != b)
# checking equality shouldn't have collapsed the generator
b2 = list(b)
self.assertFalse(a == b2)
self.assertTrue(a != b2)
def test_range(self):
range_min = 10
range_max = 20
lazy = iterlist.IterList(range(range_min, range_max))
for i in range(range_min, range_max):
self.assertTrue(i in lazy)
for i in range(0, range_min):
self.assertFalse(i in lazy)
for i in range(range_max, range_max + 10):
self.assertFalse(i in lazy)
def test_with_non_iterable(self):
a = iterlist.IterList([])
b = iterlist.IterTuple([])
c = iterlist.CachedIterator([])
d = 0
self.assertFalse(a == d)
self.assertTrue(a != d)
self.assertFalse(b == d)
self.assertTrue(b != d)
self.assertFalse(c == d)
self.assertTrue(c != d)
def test_with_tuple(self):
a = iterlist.IterList(range(range_size))
b = iterlist.IterTuple(range(range_size))
c = tuple(range(range_size))
# IterList/IterTuple equality: never equal even with same contents
self.assertTrue(a != b)
self.assertFalse(a == b)
# IterList/tuple equality
self.assertTrue(a != c)
self.assertFalse(a == c)
# IterTuple/tuple equality
self.assertTrue(b == c)
self.assertFalse(b != c)
def test_with_tuple(self):
a = iterlist.IterTuple(range(range_size))
b = iterlist.IterList(range(range_size))
c = tuple(range(-1, range_size - 1))
d = tuple(range(1, range_size + 1))
e = tuple(range(range_size))
self.assertTrue(a < d)
self.assertFalse(a < c)
self.assertFalse(a < e)
# cannot compare IterList and tuple
with self.assertRaises(TypeError):
self.assertTrue(b < d)
with self.assertRaises(TypeError):
self.assertFalse(b < c)
with self.assertRaises(TypeError):
self.assertFalse(b < e)
try:
self.assertFalse(d < a)
# XXX: doesn't actually do less than, always False
self.assertFalse(c < a)
self.assertFalse(e < a)
except TypeError:
# cannot compare tuple and IterTuple on py3
pass
def test_unordered(self):
a = iterlist.IterList([1, 9])
b = iterlist.IterList([2, -1])
self.assertTrue(a < b)
self.assertFalse(b < a)
def test_slice_from_negative_stop(self):
lazy = iterlist.IterList(range(range_size))
slz = lazy[-3:-1]
self.assertEqual(len(slz), 2)
self.assertEqual(len(lazy._list), range_size)
def test_slice_from_positive_to_end(self):
lazy = iterlist.IterList(range(range_size))
slz = lazy[2:]
self.assertEqual(len(slz), range_size - 2)
self.assertEqual(len(lazy._list), range_size)
def test_slice_from_positive(self):
lazy = iterlist.IterList(range(range_size))
slz = lazy[1:half_range]
self.assertEqual(len(slz), half_range - 1)
self.assertEqual(len(lazy._list), half_range)
def test_insert(self):
lazy = iterlist.IterList(range(range_size))
lazy.insert(2, 'a')
self.assertEqual(lazy[2], 'a')
lazy.insert(10, 'b')
self.assertEqual(lazy[10], 'b')
def test_iter_unconsumed(self):
orig = list(range(range_size))
lazy = iterlist.IterList(orig)
for ix, v in enumerate(lazy):
self.assertEqual(v, orig[ix])
def test_remove_fails(self):
lazy = iterlist.IterList(range(range_size))
for i in range(range_size, range_size * 2):
self.assertRaises(ValueError, lazy.remove, i)
def test_slice_by_2(self):
lazy = iterlist.IterList(range(range_size))
exp_size = int(math.floor(half_range / 2))
slz = lazy[0:half_range:2]
self.assertEqual(len(slz), exp_size)
self.assertLessEqual(len(lazy._list), half_range)
def test_uneven(self):
a = iterlist.IterList(range(range_size))
b = iterlist.IterList(range(range_size - 1))
self.assertTrue(b < a)
self.assertFalse(a < b)
def test_simple(self):
a = iterlist.IterList(range(1, range_size + 1))
b = iterlist.IterList(range(range_size))
self.assertTrue(b < a)
self.assertFalse(a < b)
def test_evaluated(self):
lazy = iterlist.IterList(range(range_size))
len(lazy)
lazy.clear()
self.assertEqual(len(lazy), 0)
def test_append(self):
lazy = iterlist.IterList(range(range_size // 2))
for i in range(range_size // 2, range_size):
lazy.append(i)
for i, j in zip(lazy, range(range_size)):
self.assertEqual(i, j)
def test_insert_negative(self):
lazy = iterlist.IterList(range(range_size))
lazy.insert(-1, 'c')
self.assertEqual(lazy[-2], 'c')
def test_clear_and_add(self):
lazy = iterlist.IterList(range(range_size))
lazy.clear()
self.assertEqual(len(lazy), 0)
lazy.extend(range(range_size))
self.assertEqual(len(lazy), range_size)
def test_slice_from_explicit_zero(self):
lazy = iterlist.IterList(range(range_size))
slz = lazy[0:half_range]
self.assertEqual(len(slz), half_range)
self.assertEqual(len(lazy._list), half_range)
