def test_consume(self):
# full consuming, without limitation
r = iters.range(10)
self.assertEqual(10, len(list(r)))
itr = iter(r)
iters.consume(itr)
self.assertEqual(0, len(list(itr)))
def test_splitby(self):
def is_even(x):
return x % 2 == 0
before, after = iters.splitby(is_even, iters.range(5))
self.assertEqual([0], list(before))
self.assertEqual([1, 2,3,4], list(after))
def test_partition(self):
def is_odd(x):
return x % 2 == 1
before, after = iters.partition(is_odd, iters.range(5))
self.assertEqual([0, 2, 4], list(before))
self.assertEqual([1, 3], list(after))
def test_lazy_slicing(self):
s = Stream() << iters.range(10)
self.assertEqual(s.cursor(), 0)
s_slice = s[:5]
self.assertEqual(s.cursor(), 0)
self.assertEqual(len(list(s_slice)), 5)
def test_lazy_slicing(self):
s = Stream() << iters.range(10)
self.assertEqual(s.cursor(), 0)
s_slice = s[:5]
self.assertEqual(s.cursor(), 0)
self.assertEqual(len(list(s_slice)), 5)
def test_splitby(self):
def is_even(x):
return x % 2 == 0
before, after = iters.splitby(is_even, iters.range(5))
self.assertEqual([0], list(before))
self.assertEqual([1, 2, 3, 4], list(after))
def test_consume(self):
# full consuming, without limitation
r = iters.range(10)
self.assertEqual(10, len(list(r)))
itr = iter(r)
iters.consume(itr)
self.assertEqual(0, len(list(itr)))
def test_foldr(self):
summer = op.foldr(operator.add)
self.assertEqual(10, op.foldr(operator.add)([0, 1, 2, 3, 4]))
self.assertEqual(20, op.foldr(operator.add, 10)([0, 1, 2, 3, 4]))
self.assertEqual(20, op.foldr(operator.add, 10)(iters.range(5)))
# specific case for right-side folding
self.assertEqual(100, op.foldr(op.call, 0)([lambda s: s ** 2, lambda k: k + 10]))
def test_partition(self):
def is_odd(x):
return x % 2 == 1
before, after = iters.partition(is_odd, iters.range(5))
self.assertEqual([0,2,4], list(before))
self.assertEqual([1,3], list(after))
def test_foldr(self):
summer = op.foldr(operator.add)
self.assertEqual(10, op.foldr(operator.add)([0,1,2,3,4]))
self.assertEqual(20, op.foldr(operator.add, 10)([0,1,2,3,4]))
self.assertEqual(20, op.foldr(operator.add, 10)(iters.range(5)))
# specific case for right-side folding
self.assertEqual(100,
op.foldr(op.call, 0)([lambda s: s**2, lambda k: k+10]))
def test_consume_limited(self):
r = iters.range(10)
self.assertEqual(10, len(list(r)))
itr = iter(r)
iters.consume(itr, 5)
self.assertEqual(5, len(list(itr)))
def test_foldl(self):
self.assertEqual(10, op.foldl(operator.add)([0, 1, 2, 3, 4]))
self.assertEqual(20, op.foldl(operator.add, 10)([0, 1, 2, 3, 4]))
self.assertEqual(20, op.foldl(operator.add, 10)(iters.range(5)))
self.assertEqual(10, op.foldl(_ + _)(range(5)))
def test_pipe_partial(self):
func = F() >> (iters.filter, _ < 6) >> sum
self.assertEqual(15, func(iters.range(10)))
def test_lazy_slicing_recursive(self):
s = Stream() << iters.range(10)
sf = s[1:3][0:2]
self.assertEqual(s.cursor(), 0)
self.assertEqual(len(list(sf)), 2)
def test_splitat(self):
before, after = iters.splitat(2, iters.range(5))
self.assertEqual([0, 1], list(before))
self.assertEqual([2, 3, 4], list(after))
def test_lazy_slicing_recursive(self):
s = Stream() << iters.range(10)
sf = s[1:3][0:2]
self.assertEqual(s.cursor(), 0)
self.assertEqual(len(list(sf)), 2)
def test_pipe_partial(self):
func = F() >> (iters.filter, _ < 6) >> sum
self.assertEqual(15, func(iters.range(10)))
def test_consume_limited(self):
r = iters.range(10)
self.assertEqual(10, len(list(r)))
itr = iter(r)
iters.consume(itr, 5)
self.assertEqual(5, len(list(itr)))
def test_splitat(self):
before, after = iters.splitat(2, iters.range(5))
self.assertEqual([0,1], list(before))
self.assertEqual([2,3,4], list(after))
def test_foldl(self):
self.assertEqual(10, op.foldl(operator.add)([0,1,2,3,4]))
self.assertEqual(20, op.foldl(operator.add, 10)([0,1,2,3,4]))
self.assertEqual(20, op.foldl(operator.add, 10)(iters.range(5)))
self.assertEqual(10, op.foldl(_ + _)(range(5)))
