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)