def test_seq_choose_option(): xs: Iterable[Optional[int]] = seq.of(None, 42) chooser = seq.choose(option.of_optional) ys = pipe(xs, chooser) assert list(ys) == [42]
def test_list_sort_with(xs: List[str]): expected = sorted(xs, key=lambda x: x[1]) ys: FrozenList[str] = frozenlist.of_seq(xs) func: Callable[[str], str] = lambda x: x[1] result = pipe(ys, frozenlist.sort_with(func)) assert list(result) == list(expected)
def test_seq_take(xs: List[int], x: int): ys = seq.of_iterable(xs) try: zs = pipe(ys, seq.take(x)) assert list(zs) == xs[:x] except ValueError: assert x > len(xs)
def test_list_filter(xs: List[int], limit: int): expected = filter(lambda x: x < limit, xs) ys: FrozenList[int] = frozenlist.of_seq(xs) predicate: Callable[[int], bool] = lambda x: x < limit result = pipe(ys, frozenlist.filter(predicate)) assert list(result) == list(expected)
def test_seq_pipe_starmap(xs: List[Tuple[int, int]]): mapper: Callable[[int, int], int] = lambda x, y: x + y ys = pipe( frozenlist.of_seq(xs), frozenlist.starmap(mapper), ) assert isinstance(ys, FrozenList) assert [y for y in ys] == [x + y for (x, y) in xs]
def test_seq_pipe_map3(xs: List[Tuple[int, int, int]]): mapper: Callable[[int, int, int], int] = lambda x, y, z: x + y + z ys = pipe( frozenlist.of_seq(xs), frozenlist.map3(mapper), ) assert isinstance(ys, FrozenList) assert [y for y in ys] == [x + y + z for (x, y, z) in xs]
def test_list_unfold(x: int): def unfolder(state: int) -> Option[Tuple[int, int]]: if state < x: return Some((state, state + 1)) return Nothing result = pipe(0, seq.unfold(unfolder)) assert list(result) == list(range(x))
def test_list_fold(xs: List[int]): def folder(x: int, y: int) -> int: return x + y expected: int = functools.reduce(folder, xs, 0) ys: FrozenList[int] = frozenlist.of_seq(xs) result = pipe(ys, frozenlist.fold(folder, 0)) assert result == expected
def test_map_remove(xs: Dict[str, int]): items: ItemsView[str, int] = xs.items() m = Map.of_seq(items) keys = xs.keys() count = len(m) for key in keys: m = pipe(m, map.remove(key)) count -= 1 assert len(m) == count == 0
def test_map_to_seq(xs: Dict[str, int]): items: List[Tuple[str, int]] = list(xs.items()) ys = map.of_list(items) zs = pipe(ys, map.to_seq) assert sorted(list(items)) == list(zs)
def test_seq_pipe_map3(xs: List[Tuple[int, int, int]]): mapper: Callable[[int, int, int], int] = lambda x, y, z: x + y + z ys = pipe(xs, seq.map3(mapper)) assert isinstance(ys, Iterable) assert [y for y in ys] == [x + y + z for (x, y, z) in xs]
def test_seq_pipe_map(xs: List[int]): mapper: Callable[[int], int] = lambda x: x + 1 ys = pipe(xs, seq.map(mapper)) assert isinstance(ys, Iterable) assert [y for y in ys] == [x + 1 for x in xs]
def test_seq_append_3(xs: List[int], ys: List[int], zs: List[int]): value = pipe(xs, seq.append(ys, zs)) assert list(value) == xs + ys + zs
def test_list_non_empty(): xs = frozenlist.singleton(42) assert len(xs) == 1 assert xs assert not pipe(xs, frozenlist.is_empty)
def test_list_empty(): xs = frozenlist.empty assert len(xs) == 0 assert not xs assert pipe(xs, frozenlist.is_empty)
def test_list_sort(xs: List[int]): expected = sorted(xs) ys: FrozenList[int] = frozenlist.of_seq(xs) result = pipe(ys, frozenlist.sort()) assert list(result) == list(expected)
def test_seq_scan_pipe(xs: List[int], s: int): func: Callable[[int, int], int] = lambda s, v: s + v value = pipe(seq.of_iterable(xs), seq.scan(func, s)) expected: Iterable[int] = accumulate(xs, func, initial=s) assert list(value) == list(expected)
def test_list_cons_head(value: Any): x = pipe(frozenlist.empty.cons(value), frozenlist.head) assert x == value
def test_seq_collect(xs: List[int]): collector = seq.collect(seq.singleton) ys = pipe(xs, collector) assert list(xs) == list(ys)
def test_pipe_fn(x: int): value = pipe(x, lambda x: x + 1) assert value == x + 1
def test_seq_length(xs: List[int]): ys = seq.of_iterable(xs) n = pipe(ys, seq.length) assert n == len(xs)
def test_pipe_fn_gn(x: int, y: int, z: int): gn: Callable[[int], int] = lambda g: g * y fn: Callable[[int], int] = lambda x: x + z value = pipe(x, fn, gn) assert value == gn(fn(x))
def test_seq_infinite(xs: List[int]): ys = pipe(xs, seq.zip(seq.infinite)) expected = list(enumerate(xs)) assert expected == list(ys)
def test_pipe_id(x: int): value = pipe(x) assert value == x
def test_seq_pipe_starmap(xs: List[Tuple[int, int]]): mapper: Callable[[int, int], int] = lambda x, y: x + y ys = pipe(xs, seq.starmap(mapper)) assert isinstance(ys, Iterable) assert [y for y in ys] == [x + y for (x, y) in xs]
def test_seq_head_pipe(xs: List[int]): value = pipe(xs, seq.head) assert value == xs[0]
def test_seq_pipe_mapi(xs: List[int]): mapper: Callable[[int, int], int] = lambda i, x: x + i ys = pipe(xs, seq.mapi(mapper)) assert isinstance(ys, Iterable) assert [y for y in ys] == [x + i for i, x in enumerate(xs)]
def test_seq_head_empty_source(): with pytest.raises(ValueError): pipe(Seq.empty(), seq.head)
def test_seq_fold_pipe(xs: List[int], s: int): folder: Callable[[int, int], int] = lambda s, v: s + v value = pipe(seq.of_iterable(xs), seq.fold(folder, s)) assert value == sum(xs) + s
def test_option_some(): xs = Some(42) assert isinstance(xs, Option) assert pipe(xs, option.is_some) is True assert pipe(xs, option.is_none) is False