def test_list_append(xs: List[int], ys: List[int]):
expected = xs + ys
fx = frozenlist.of_seq(xs)
fy = frozenlist.of_seq(ys)
fz = fx.append(fy)
fh = fx + fy
assert list(fz) == list(fh) == expected
def test_list_skip(xs: List[int], x: int):
ys: FrozenList[int]
try:
ys = frozenlist.of_seq(xs).skip(x)
assert list(ys) == xs[x:]
except ValueError:
assert x > len(xs)
def test_list_slice(xs: PyList[int], x: int, y: int):
expected = xs[x:y]
ys: FrozenList[int]
ys = frozenlist.of_seq(xs)[x:y]
assert pylist(ys) == expected
def test_list_take(xs: PyList[int], x: int):
ys: FrozenList[int]
try:
ys = frozenlist.of_seq(xs).take(x)
assert pylist(ys) == xs[:x]
except ValueError:
assert x > len(xs)
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_list_monad_law_associativity_iterable(xs: List[int]):
# (m >>= f) >>= g is just like doing m >>= (\x -> f x >>= g)
f: Callable[[int], FrozenList[int]] = lambda x: rtn(x + 10)
g: Callable[[int], FrozenList[int]] = lambda y: rtn(y * 42)
m = frozenlist.of_seq(xs)
assert m.collect(f).collect(g) == m.collect(lambda x: f(x).collect(g))
def test_list_slice(xs: List[int], x: int, y: int):
expected = xs[x:y]
ys: FrozenList[int] = frozenlist.of_seq(xs)
zs = ys[x:y]
assert list(zs) == expected
def test_list_indexed(xs: List[int]):
expected = list(enumerate(xs))
ys: FrozenList[int] = frozenlist.of_seq(xs)
zs = frozenlist.indexed(ys)
assert list(zs) == expected
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_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_pipe_mapi(xs: List[int]):
def mapper(i: int, x: int):
return x + i
ys = frozenlist.of_seq(xs)
zs = ys.pipe(frozenlist.mapi(mapper))
assert isinstance(zs, FrozenList)
assert [z for z in zs] == [x + i for i, x in enumerate(xs)]
def test_list_pipe_map(xs: List[int]):
def mapper(x: int):
return x + 1
ys = frozenlist.of_seq(xs)
zs = ys.pipe(frozenlist.map(mapper))
assert isinstance(zs, FrozenList)
assert [y for y in zs] == [mapper(x) for x in xs]
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_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_list_index(xs: List[int], x: int):
x = x % len(xs) if x > 0 else x
expected = xs[x]
ys: FrozenList[int] = frozenlist.of_seq(xs)
y = ys[x]
item: Callable[[FrozenList[int]], int] = frozenlist.item(x)
h = ys.pipe(item)
i = ys.item(x)
assert y == h == i == expected
def test_list_large_list(x: int):
xs = frozenlist.of_seq(range(x))
assert len(xs) == x
def test_list_item(xs: List[int], index: int):
ys = frozenlist.of_seq(xs)
while index and index >= len(xs):
index //= 2
assert xs[index] == ys[index]
def test_list_length(xs: List[int]):
ys = frozenlist.of_seq(xs)
assert len(xs) == len(ys)
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_list_take_last(xs: List[int], x: int):
expected = xs[-x:]
ys: FrozenList[int]
ys = frozenlist.of_seq(xs).take_last(x)
assert list(ys) == expected
def test_list_skip_last(xs: List[int], x: int):
expected = xs[:-x]
ys: FrozenList[int]
ys = frozenlist.of_seq(xs).skip_last(x)
assert list(ys) == expected