import itertools
from itertools import *
import math


def lzip(*args):
    return list(zip(*args))


def onearg(x):
    "Test function of one argument"
    return 2 * x


def errfunc(*args):
    "Test function that raises an error"
    raise ValueError()


def gen3():
    "Non-restartable source sequence"
    for i in (0, 1, 2):
        yield i


def isEven(x):
    "Test predicate"
    return x % 2 == 0


def isOdd(x):
    "Test predicate"
    return x % 2 == 1


def tupleize(*args):
    return args


def irange(n):
    for i in range(n):
        yield i


def take(n, seq):
    "Convenience function for partially consuming a long of infinite iterable"
    return list(islice(seq, n))


def testR(r):
    return r[0]


def testR2(r):
    return r[2]


def underten(x):
    return x < 10


@test
def test_combinations():
    assert list(itertools.combinations("ABCD", 2)) == [
        ["A", "B"],
        ["A", "C"],
        ["A", "D"],
        ["B", "C"],
        ["B", "D"],
        ["C", "D"],
    ]
    test_intermediate = itertools.combinations("ABCD", 2)
    next(test_intermediate)
    assert list(test_intermediate) == [
        ["A", "C"],
        ["A", "D"],
        ["B", "C"],
        ["B", "D"],
        ["C", "D"],
    ]
    assert list(itertools.combinations(range(4), 3)) == [
        [0, 1, 2],
        [0, 1, 3],
        [0, 2, 3],
        [1, 2, 3],
    ]
    test_intermediat = itertools.combinations(range(4), 3)
    next(test_intermediat)
    assert list(test_intermediat) == [[0, 1, 3], [0, 2, 3], [1, 2, 3]]


@test
def test_combinations_with_replacement():
    assert list(itertools.combinations_with_replacement(range(3), 3)) == [
        [0, 0, 0],
        [0, 0, 1],
        [0, 0, 2],
        [0, 1, 1],
        [0, 1, 2],
        [0, 2, 2],
        [1, 1, 1],
        [1, 1, 2],
        [1, 2, 2],
        [2, 2, 2],
    ]
    assert list(itertools.combinations_with_replacement("ABC", 2)) == [
        ["A", "A"],
        ["A", "B"],
        ["A", "C"],
        ["B", "B"],
        ["B", "C"],
        ["C", "C"],
    ]
    test_intermediate = itertools.combinations_with_replacement("ABC", 2)
    next(test_intermediate)
    assert list(test_intermediate) == [
        ["A", "B"],
        ["A", "C"],
        ["B", "B"],
        ["B", "C"],
        ["C", "C"],
    ]


@test
def test_islice():
    ra100 = range(100)
    ra = range(10)
    assert list(itertools.islice(iter("ABCDEFG"), 0, 2, 1)) == ["A", "B"]
    assert list(itertools.islice(iter(ra100), 10, 20, 3)) == [10, 13, 16, 19]
    assert list(itertools.islice(iter(ra100), 10, 3, 20)) == []
    assert list(itertools.islice(iter(ra100), 10, 20, 1)) == [
        10,
        11,
        12,
        13,
        14,
        15,
        16,
        17,
        18,
        19,
    ]
    assert list(itertools.islice(iter(ra100), 10, 10, 1)) == []
    assert list(itertools.islice(iter(ra100), 10, 3, 1)) == []
    # stop=len(iterable)
    assert list(itertools.islice(iter(ra), 0, 10, 1)) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    assert list(itertools.islice(iter(ra), 2, 10, 1)) == [2, 3, 4, 5, 6, 7, 8, 9]
    assert list(itertools.islice(iter(ra), 1, 10, 2)) == [1, 3, 5, 7, 9]
    try:
        list(itertools.islice(iter(ra), -5, 10, 1))
        assert False
    except ValueError:
        pass


@test
def test_count():
    # infinite loop here
    assert take(3, itertools.count(3.25, 1.0)) == [3.25, 4.25, 5.25]
    assert take(3, zip("abc", itertools.count(3.25, 1.0))) == [
        ("a", 3.25),
        ("b", 4.25),
        ("c", 5.25),
    ]
    assert take(2, zip("abc", itertools.count(-1.0, 1.0))) == [("a", -1.0), ("b", 0.0)]
    assert take(2, zip("abc", itertools.count(-3.0, 1.0))) == [("a", -3.0), ("b", -2.0)]


@test
def test_repeat():
    assert list(itertools.repeat("a", 3)) == ["a", "a", "a"]
    assert list(itertools.repeat(1, 10)) == [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
    assert list(itertools.repeat("a", -1)) == []
    assert len(list(itertools.repeat("a", 0))) == 0


@test
def test_cycle():
    assert take(10, zip("zzzzzzzzzzz", itertools.cycle(iter("abc")))) == [
        ("z", "a"),
        ("z", "b"),
        ("z", "c"),
        ("z", "a"),
        ("z", "b"),
        ("z", "c"),
        ("z", "a"),
        ("z", "b"),
        ("z", "c"),
        ("z", "a"),
    ]
    assert take(10, zip("zzzzzzzzzzz", itertools.cycle(["a", "b"]))) == [
        ("z", "a"),
        ("z", "b"),
        ("z", "a"),
        ("z", "b"),
        ("z", "a"),
        ("z", "b"),
        ("z", "a"),
        ("z", "b"),
        ("z", "a"),
        ("z", "b"),
    ]


@test
def test_compress():
    assert list(itertools.compress("ABCDEF", [1, 0, 1, 0, 1, 1])) == [
        "A",
        "C",
        "E",
        "F",
    ]
    assert list(itertools.compress("ABCDEF", [1, 1, 1, 1, 1, 1])) == [
        "A",
        "B",
        "C",
        "D",
        "E",
        "F",
    ]
    assert list(itertools.compress("ABCDEF", [1, 0, 1])) == ["A", "C"]
    assert list(itertools.compress("ABC", [0, 1, 1, 1, 1, 1])) == ["B", "C"]


@test
def test_dropwhile():
    data = [1, 3, 5, 20, 2, 4, 6, 8]
    assert list(itertools.dropwhile(underten, data)) == [20, 2, 4, 6, 8]


@test
def test_takewhile():
    data = [1, 3, 5, 20, 2, 4, 6, 8]
    assert list(itertools.takewhile(underten, data)) == [1, 3, 5]


@test
def test_filterfalse():
    assert list(itertools.filterfalse(isEven, range(10))) == [1, 3, 5, 7, 9]
    assert list(itertools.filterfalse(lambda x: bool(x), [0, 1, 0, 2, 0])) == [0, 0, 0]


@test
def test_permutations():
    assert list(itertools.permutations(range(3), 2)) == [
        [0, 1],
        [0, 2],
        [1, 0],
        [1, 2],
        [2, 0],
        [2, 1],
    ]

    for n in range(3):
        values = [5 * x - 12 for x in range(n)]
        for r in range(n + 2):
            result = list(itertools.permutations(values, r))
            if r > n:  # right number of perms
                assert len(result) == 0
            # factorial is not yet implemented in math
            # else: fact(n) / fact(n - r)


@test
def test_accumulate():
    # addition
    assert list(itertools.accumulate(range(10), int.__add__, initial=0)) == [
        0,
        0,
        1,
        3,
        6,
        10,
        15,
        21,
        28,
        36,
        45,
    ]
    assert list(itertools.accumulate([7], int.__add__, initial=0)) == [
        0,
        7,
    ]  # iterable of length 1
    assert list(itertools.accumulate(range(10), int.__add__)) == [
        0,
        1,
        3,
        6,
        10,
        15,
        21,
        28,
        36,
        45,
    ]
    assert list(itertools.accumulate([7], int.__add__)) == [7]  # iterable of length 1
    assert list(itertools.accumulate("abc", str.__add__, initial="")) == [
        "",
        "a",
        "ab",
        "abc",
    ]
    assert list(itertools.accumulate([""], str.__add__, initial=str(0))) == ["0", "0"]
    # multiply
    assert list(itertools.accumulate(range(10), int.__mul__, initial=0)) == [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
    ]
    assert list(itertools.accumulate([1, 2, 3, 4, 5], int.__mul__, initial=1)) == [
        1,
        1,
        2,
        6,
        24,
        120,
    ]
    assert list(itertools.accumulate([7], int.__mul__)) == [7]
    # pass


@test
def test_chain():
    assert list(itertools.chain("abc", "def")) == ["a", "b", "c", "d", "e", "f"]
    assert list(itertools.chain("abc")) == ["a", "b", "c"]
    assert list(itertools.chain("a", "b", "c")) == ["a", "b", "c"]
    assert list(itertools.chain(["abc", "def"])) == ["abc", "def"]
    assert list(itertools.chain(["abc"])) == ["abc"]
    assert list(itertools.chain(["a", "b", "c"])) == ["a", "b", "c"]


@test
def test_starmap():
    assert list(itertools.starmap(math.pow, [(2.0, 5.0), (3.0, 2.0), (10.0, 3.0)])) == [
        32.0,
        9.0,
        1000.0,
    ]
    assert list(itertools.starmap(math.pow, [(0.0, 1.0), (1.0, 2.0), (2.0, 3.0)])) == [
        0.0 ** 1.0,
        1.0 ** 2.0,
        2.0 ** 3.0,
    ]


@test
def test_groupby():
    def key_str(s: str):
        return s

    assert list(itertools.groupby(iter("AAAABBBCCDAABBC"), key_str)) == [
        ("A", ["A", "A", "A", "A"]),
        ("B", ["B", "B", "B"]),
        ("C", ["C", "C"]),
        ("D", ["D"]),
        ("A", ["A", "A"]),
        ("B", ["B", "B"]),
        ("C", ["C"]),
    ]


@test
def test_zip_longest():
    assert list(itertools.zip_longest("ABCDE", "12345", fillvalue="-")) == [
        ("A", "1"),
        ("B", "2"),
        ("C", "3"),
        ("D", "4"),
        ("E", "5"),
    ]
    assert list(itertools.zip_longest("ABCDE", "123", fillvalue="-")) == [
        ("A", "1"),
        ("B", "2"),
        ("C", "3"),
        ("D", "-"),
        ("E", "-"),
    ]
    assert list(itertools.zip_longest("123", "ABCDE", fillvalue="-")) == [
        ("1", "A"),
        ("2", "B"),
        ("3", "C"),
        ("-", "D"),
        ("-", "E"),
    ]
    assert list(itertools.zip_longest("", "ABCDE", fillvalue="-")) == [
        ("-", "A"),
        ("-", "B"),
        ("-", "C"),
        ("-", "D"),
        ("-", "E"),
    ]
    assert list(itertools.zip_longest("ABCDE", "", fillvalue="-")) == [
        ("A", "-"),
        ("B", "-"),
        ("C", "-"),
        ("D", "-"),
        ("E", "-"),
    ]
    assert not list(itertools.zip_longest("", "", fillvalue="-"))


@test
def test_zip_test():
    assert list(zip()) == []
    assert list(zip((1, 2))) == [(1,), (2,)]
    assert list(zip([1, 2], ["a", "b"], (False, True))) == [
        (1, "a", False),
        (2, "b", True),
    ]


test_combinations()
test_combinations_with_replacement()
test_islice()
test_count()
test_repeat()
test_cycle()
test_compress()
test_dropwhile()
test_takewhile()
test_filterfalse()
test_permutations()
test_accumulate()
test_chain()
test_starmap()
test_groupby()
test_zip_longest()
test_zip_test()


# Updated tests lifted from CPython test suite


@test
def test_accumulate_from_cpython():
    assert list(accumulate(range(10))) == [0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
    assert list(accumulate(iterable=range(10))) == [0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
    assert list(accumulate("abc")) == ["a", "ab", "abc"]
    assert list(accumulate(List[float]())) == []
    assert list(accumulate([7])) == [7]

    s = [2, 8, 9, 5, 7, 0, 3, 4, 1, 6]
    assert list(accumulate(s, min)) == [2, 2, 2, 2, 2, 0, 0, 0, 0, 0]
    assert list(accumulate(s, max)) == [2, 8, 9, 9, 9, 9, 9, 9, 9, 9]
    mul = lambda a, b: a * b
    assert list(accumulate(s, mul)) == [2, 16, 144, 720, 5040, 0, 0, 0, 0, 0]

    # assert list(accumulate([10, 5, 1], initial=None)) == [10, 15, 16]
    assert list(accumulate([10, 5, 1], initial=100)) == [100, 110, 115, 116]
    assert list(accumulate([10, 5, 1], initial=100.5)) == [100.5, 110.5, 115.5, 116.5]
    assert list(accumulate(List[int](), initial=100)) == [100]


test_accumulate_from_cpython()


@test
def test_chain_from_cpython():
    assert list(chain("abc", "def")) == list("abcdef")
    assert list(chain("abc")) == list("abc")
    assert list(chain("")) == []
    assert list(take(4, chain("abc", "def"))) == list("abcd")


test_chain_from_cpython()


@test
def test_chain_from_iterable_from_cpython():
    assert list(chain.from_iterable(["abc", "def"])) == list("abcdef")
    assert list(chain.from_iterable(["abc"])) == list("abc")
    assert list(chain.from_iterable([""])) == []
    assert take(4, chain.from_iterable(["abc", "def"])) == list("abcd")


test_chain_from_iterable_from_cpython()


@test
def test_combinations_from_cpython():
    from math import factorial as fact

    err = False
    try:
        list(combinations("abc", -2))
        assert False
    except ValueError:
        err = True
    assert err

    assert list(combinations("abc", 32)) == []  # r > n
    assert list(combinations("ABCD", 2)) == [
        ["A", "B"],
        ["A", "C"],
        ["A", "D"],
        ["B", "C"],
        ["B", "D"],
        ["C", "D"],
    ]
    assert list(combinations(range(4), 3)) == [
        [0, 1, 2],
        [0, 1, 3],
        [0, 2, 3],
        [1, 2, 3],
    ]

    for n in range(7):
        values = [5 * x - 12 for x in range(n)]
        for r in range(n + 2):
            result = list(combinations(values, r))

            assert len(result) == (0 if r > n else fact(n) // fact(r) // fact(n - r))
            assert len(result) == len(set(result))  # no repeats
            # assert result == sorted(result)                     # lexicographic order
            for c in result:
                assert len(c) == r  # r-length combinations
                assert len(set(c)) == r  # no duplicate elements
                assert list(c) == sorted(c)  # keep original ordering
                assert all(e in values for e in c)  # elements taken from input iterable
                assert list(c) == [
                    e for e in values if e in c
                ]  # comb is a subsequence of the input iterable


test_combinations_from_cpython()


@test
def test_combinations_with_replacement_from_cpython():
    cwr = combinations_with_replacement
    err = False
    try:
        list(cwr("abc", -2))
        assert False
    except ValueError:
        err = True
    assert err

    assert list(cwr("ABC", 2)) == [
        ["A", "A"],
        ["A", "B"],
        ["A", "C"],
        ["B", "B"],
        ["B", "C"],
        ["C", "C"],
    ]

    def numcombs(n, r):
        from math import factorial as fact

        if not n:
            return 0 if r else 1
        return fact(n + r - 1) // fact(r) // fact(n - 1)

    for n in range(7):
        values = [5 * x - 12 for x in range(n)]
        for r in range(n + 2):
            result = list(cwr(values, r))
            regular_combs = list(combinations(values, r))

            assert len(result) == numcombs(n, r)
            assert len(result) == len(set(result))  # no repeats
            # assert result == sorted(result)                     # lexicographic order

            if n == 0 or r <= 1:
                assert result == regular_combs  # cases that should be identical
            else:
                assert set(result) >= set(regular_combs)

            for c in result:
                assert len(c) == r  # r-length combinations
                noruns = [k for k, v in groupby(c)]  # combo without consecutive repeats
                assert len(noruns) == len(
                    set(noruns)
                )  # no repeats other than consecutive
                assert list(c) == sorted(c)  # keep original ordering
                assert all(e in values for e in c)  # elements taken from input iterable
                assert noruns == [
                    e for e in values if e in c
                ]  # comb is a subsequence of the input iterable


test_combinations_with_replacement_from_cpython()


@test
def test_permutations_from_cpython():
    from math import factorial as fact

    err = False
    try:
        list(permutations("abc", -2))
        assert False
    except ValueError:
        err = True
    assert err

    assert list(permutations("abc", 32)) == []
    assert list(permutations(range(3), 2)) == [
        [0, 1],
        [0, 2],
        [1, 0],
        [1, 2],
        [2, 0],
        [2, 1],
    ]

    for n in range(7):
        values = [5 * x - 12 for x in range(n)]
        for r in range(n + 2):
            result = list(permutations(values, r))
            assert len(result) == (
                0 if r > n else fact(n) // fact(n - r)
            )  # right number of perms
            assert len(result) == len(set(result))  # no repeats
            # assert result == sorted(result)                # lexicographic order
            for p in result:
                assert len(p) == r  # r-length permutations
                assert len(set(p)) == r  # no duplicate elements
                assert all(e in values for e in p)  # elements taken from input iterable

            if r == n:
                assert result == list(permutations(values, None))  # test r as None
                assert result == list(permutations(values))  # test default r


test_permutations_from_cpython()


@extend
class List:
    def __lt__(self, other: List[T]):
        if len(self) != len(other):
            return len(self) < len(other)
        for a, b in zip(self, other):
            if a < b:
                return True
            if a > b:
                return False
        return False

    def __le__(self, other: List[T]):
        if len(self) != len(other):
            return len(self) < len(other)
        for a, b in zip(self, other):
            if a < b:
                return True
            if a > b:
                return False
        return True

    def __gt__(self, other: List[T]):
        if len(self) != len(other):
            return len(self) < len(other)
        for a, b in zip(self, other):
            if a > b:
                return True
            if a < b:
                return False
        return False

    def __ge__(self, other: List[T]):
        if len(self) != len(other):
            return len(self) < len(other)
        for a, b in zip(self, other):
            if a > b:
                return True
            if a < b:
                return False
        return True


@test
def test_combinatorics_from_cpython():
    # Test relationships between product(), permutations(),
    # combinations() and combinations_with_replacement().
    from math import factorial as fact

    for n in range(6):
        s = "ABCDEFG"[:n]
        for r in range(8):
            prod = list(product(s, repeat=r))
            cwr = list(combinations_with_replacement(s, r))
            perm = list(permutations(s, r))
            comb = list(combinations(s, r))

            # Check size
            assert len(prod) == n ** r
            assert len(cwr) == (
                (fact(n + r - 1) // fact(r) // fact(n - 1)) if n else (0 if r else 1)
            )
            assert len(perm) == (0 if r > n else fact(n) // fact(n - r))
            assert len(comb) == (0 if r > n else fact(n) // fact(r) // fact(n - r))

            # Check lexicographic order without repeated tuples
            assert prod == sorted(set(prod))
            assert cwr == sorted(set(cwr))
            assert perm == sorted(set(perm))
            assert comb == sorted(set(comb))

            # Check interrelationships
            assert cwr == [
                t for t in prod if sorted(t) == list(t)
            ]  # cwr: prods which are sorted
            assert perm == [
                t for t in prod if len(set(t)) == r
            ]  # perm: prods with no dups
            assert comb == [
                t for t in perm if sorted(t) == list(t)
            ]  # comb: perms that are sorted
            assert comb == [
                t for t in cwr if len(set(t)) == r
            ]  # comb: cwrs without dups
            assert comb == list(
                filter(set(cwr).__contains__, perm)
            )  # comb: perm that is a cwr
            assert comb == list(
                filter(set(perm).__contains__, cwr)
            )  # comb: cwr that is a perm
            assert comb == sorted(set(cwr) & set(perm))  # comb: both a cwr and a perm


test_combinatorics_from_cpython()


@test
def test_compress_from_cpython():
    assert list(compress(data="ABCDEF", selectors=[1, 0, 1, 0, 1, 1])) == list("ACEF")
    assert list(compress("ABCDEF", [1, 0, 1, 0, 1, 1])) == list("ACEF")
    assert list(compress("ABCDEF", [0, 0, 0, 0, 0, 0])) == list("")
    assert list(compress("ABCDEF", [1, 1, 1, 1, 1, 1])) == list("ABCDEF")
    assert list(compress("ABCDEF", [1, 0, 1])) == list("AC")
    assert list(compress("ABC", [0, 1, 1, 1, 1, 1])) == list("BC")
    n = 10000
    data = chain.from_iterable(repeat(range(6), n))
    selectors = chain.from_iterable(repeat((0, 1)))
    assert list(compress(data, selectors)) == [1, 3, 5] * n


test_compress_from_cpython()


@test
def test_count_from_cpython():
    assert lzip("abc", count()) == [("a", 0), ("b", 1), ("c", 2)]
    assert lzip("abc", count(3)) == [("a", 3), ("b", 4), ("c", 5)]
    assert take(2, lzip("abc", count(3))) == [("a", 3), ("b", 4)]
    assert take(2, zip("abc", count(-1))) == [("a", -1), ("b", 0)]
    assert take(2, zip("abc", count(-3))) == [("a", -3), ("b", -2)]
    assert take(3, count(3.25)) == [3.25, 4.25, 5.25]


test_count_from_cpython()


@test
def test_count_with_stride_from_cpython():
    assert lzip("abc", count(2, 3)) == [("a", 2), ("b", 5), ("c", 8)]
    assert lzip("abc", count(start=2, step=3)) == [("a", 2), ("b", 5), ("c", 8)]
    assert lzip("abc", count(step=-1)) == [("a", 0), ("b", -1), ("c", -2)]
    assert lzip("abc", count(2, 0)) == [("a", 2), ("b", 2), ("c", 2)]
    assert lzip("abc", count(2, 1)) == [("a", 2), ("b", 3), ("c", 4)]
    assert lzip("abc", count(2, 3)) == [("a", 2), ("b", 5), ("c", 8)]
    assert take(3, count(2.0, 1.25)) == [2.0, 3.25, 4.5]


test_count_with_stride_from_cpython()


@test
def test_cycle_from_cpython():
    assert take(10, cycle("abc")) == list("abcabcabca")
    assert list(cycle("")) == []
    assert list(islice(cycle(gen3()), 10)) == [0, 1, 2, 0, 1, 2, 0, 1, 2, 0]


test_cycle_from_cpython()


@test
def test_groupby_from_cpython():
    # Check whether it accepts arguments correctly
    assert [] == list(groupby(List[int]()))
    assert [] == list(groupby(List[int](), key=lambda a: a))
    # Check normal input
    if 1:
        s = [
            (0, 10, 20),
            (0, 11, 21),
            (0, 12, 21),
            (1, 13, 21),
            (1, 14, 22),
            (2, 15, 22),
            (3, 16, 23),
            (3, 17, 23),
        ]

        if 1:
            dup = []
            for k, g in groupby(s, lambda r: r[0]):
                for elem in g:
                    assert k == elem[0]
                    dup.append(elem)
            assert s == dup

        # Check nested case
        if 1:
            dup = []
            for k, g in groupby(s, testR):
                for ik, ig in groupby(g, testR2):
                    for elem in ig:
                        assert k == elem[0]
                        assert ik == elem[2]
                        dup.append(elem)
            assert s == dup

        # Check case where inner iterator is not used
        keys = [k for k, g in groupby(s, testR)]
        expectedkeys = set([r[0] for r in s])
        assert set(keys) == expectedkeys
        assert len(keys) == len(expectedkeys)

    if 1:
        # Exercise pipes and filters style
        s = "abracadabra"
        if 1:
            # sort s | uniq
            r = [k for k, g in groupby(sorted(s))]
            assert r == ["a", "b", "c", "d", "r"]
        if 1:
            # sort s | uniq -d
            r = [k for k, g in groupby(sorted(s)) if list(islice(g, 1, 2))]
            assert r == ["a", "b", "r"]
        if 1:
            # sort s | uniq -c
            r = [(len(list(g)), k) for k, g in groupby(sorted(s))]
            assert r == [(5, "a"), (2, "b"), (1, "c"), (1, "d"), (2, "r")]
        if 1:
            # sort s | uniq -c | sort -rn | head -3
            r = sorted(
                [(len(list(g)), k) for k, g in groupby(sorted(s))], reverse=True
            )[:3]
            assert r == [(5, "a"), (2, "r"), (2, "b")]


test_groupby_from_cpython()


@test
def test_filter_from_cpython():
    assert list(filter(isEven, range(6))) == [0, 2, 4]
    # assert list(filter(None, [0,1,0,2,0])) == [1,2]  # TODO
    assert list(filter(lambda x: bool(x), [0, 1, 0, 2, 0])) == [1, 2]
    assert take(4, filter(isEven, count())) == [0, 2, 4, 6]


test_filter_from_cpython()


@test
def test_filterfalse_from_cpython():
    assert list(filterfalse(isEven, range(6))) == [1, 3, 5]
    # assert list(filter(None, [0,1,0,2,0])) == [0,0,0]  # TODO
    assert list(filterfalse(lambda x: bool(x), [0, 1, 0, 2, 0])) == [0, 0, 0]
    assert take(4, filterfalse(isEven, count())) == [1, 3, 5, 7]


test_filterfalse_from_cpython()


@test
def test_zip_from_cpython():
    ans = [(x, y) for x, y in zip("abc", count())]
    assert ans == [("a", 0), ("b", 1), ("c", 2)]
    assert list(zip("abc", range(6))) == lzip("abc", range(6))
    assert list(zip("abcdef", range(3))) == lzip("abcdef", range(3))
    assert take(3, zip("abcdef", count())) == lzip("abcdef", range(3))
    assert list(zip("abcdef")) == lzip("abcdef")
    assert list(zip()) == lzip()
    assert [pair for pair in zip("abc", "def")] == lzip("abc", "def")


test_zip_from_cpython()


@test
def test_ziplongest_from_cpython():
    for args in (
        (range(1000), range(2000, 2100), range(3000, 3050)),
        (range(1000), range(0), range(3000, 3050), range(1200), range(1500)),
        (range(1000), range(0), range(3000, 3050), range(1200), range(1500), range(0)),
    ):
        target = [
            tuple(arg[i] if i < len(arg) else None for arg in args)
            for i in range(max(map(len, args)))
        ]
        assert str(list(zip_longest(*args))) == str(target)
        target2 = [
            [(-999 if e is None else e.__val__()) for e in t] for t in target
        ]  # Replace None fills with 'X'
        assert list(zip_longest(*args, fillvalue=-999)) == target2

    assert (
        str(list(zip_longest("abc", range(6))))
        == "[('a', 0), ('b', 1), ('c', 2), (None, 3), (None, 4), (None, 5)]"
    )
    assert (
        str(list(zip_longest(range(6), "abc")))
        == "[(0, 'a'), (1, 'b'), (2, 'c'), (3, None), (4, None), (5, None)]"
    )


test_ziplongest_from_cpython()


@test
def test_product_from_cpython():
    for args, result in (
        # ((), [()]),                     # zero iterables  # TODO
        (("ab",), [("a",), ("b",)]),  # one iterable
        (
            (range(2), range(3)),
            [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)],
        ),  # two iterables
        (
            (range(0), range(2), range(3)),
            List[Tuple[int, int, int]](),
        ),  # first iterable with zero length
        (
            (range(2), range(0), range(3)),
            List[Tuple[int, int, int]](),
        ),  # middle iterable with zero length
        (
            (range(2), range(3), range(0)),
            List[Tuple[int, int, int]](),
        ),  # last iterable with zero length
    ):
        assert list(product(*args)) == result

    assert (
        len(list(product(range(7), range(7), range(7), range(7), range(7), range(7))))
        == 7 ** 6
    )


test_product_from_cpython()


@test
def test_repeat_from_cpython():
    assert list(repeat(object="a", times=3)) == ["a", "a", "a"]
    assert lzip(range(3), repeat("a")) == [(0, "a"), (1, "a"), (2, "a")]
    assert list(repeat("a", 3)) == ["a", "a", "a"]
    assert take(3, repeat("a")) == ["a", "a", "a"]
    assert list(repeat("a", 0)) == []
    assert list(repeat("a", -3)) == []


test_repeat_from_cpython()


@test
def test_map_from_cpython():
    power = lambda a, b: a ** b
    assert list(map(power, range(3), range(1, 7))) == [0 ** 1, 1 ** 2, 2 ** 3]
    assert list(map(tupleize, "abc", range(5))) == [("a", 0), ("b", 1), ("c", 2)]
    assert list(map(tupleize, "abc", count())) == [("a", 0), ("b", 1), ("c", 2)]
    assert take(2, map(tupleize, "abc", count())) == [("a", 0), ("b", 1)]
    assert list(map(tupleize, List[int]())) == []


test_map_from_cpython()


@test
def test_starmap_from_cpython():
    power = lambda a, b: a ** b
    assert list(starmap(power, zip(range(3), range(1, 7)))) == [0 ** 1, 1 ** 2, 2 ** 3]
    assert take(3, starmap(power, zip(count(), count(1)))) == [0 ** 1, 1 ** 2, 2 ** 3]
    # assert list(starmap(tupleize, List[int]())) == []  # TODO
    assert list(starmap(power, [(4, 5)])) == [4 ** 5]


test_starmap_from_cpython()


@test
def test_islice_from_cpython():
    for args in (  # islice(args) should agree with range(args)
        (10, 20, 3),
        (10, 3, 20),
        (10, 20),
        (10, 10),
        (10, 3),
        (20,),
    ):
        assert list(islice(range(100), *args)) == list(range(*args))

    for args, tgtargs in (  # Stop when seqn is exhausted
        ((10, 110, 3), ((10, 100, 3))),
        ((10, 110), ((10, 100))),
        ((110,), (100,)),
    ):
        assert list(islice(range(100), *args)) == list(range(*tgtargs))

    # Test stop=None
    assert list(islice(range(10), None)) == list(range(10))
    assert list(islice(range(10), None, None)) == list(range(10))
    assert list(islice(range(10), None, None, None)) == list(range(10))
    assert list(islice(range(10), 2, None)) == list(range(2, 10))
    assert list(islice(range(10), 1, None, 2)) == list(range(1, 10, 2))


test_islice_from_cpython()


@test
def test_takewhile_from_cpython():
    data = [1, 3, 5, 20, 2, 4, 6, 8]
    assert list(takewhile(underten, data)) == [1, 3, 5]
    assert list(takewhile(underten, List[int]())) == []
    t = takewhile(lambda x: bool(x), [1, 1, 1, 0, 0, 0])
    assert list(t) == [1, 1, 1]


test_takewhile_from_cpython()


@test
def test_dropwhile_from_cpython():
    data = [1, 3, 5, 20, 2, 4, 6, 8]
    assert list(dropwhile(underten, data)) == [20, 2, 4, 6, 8]
    assert list(dropwhile(underten, List[int]())) == []


test_dropwhile_from_cpython()


@test
def test_tee_from_cpython():
    import random

    n = 200

    a, b = tee(List[int]())  # test empty iterator
    assert list(a) == []
    assert list(b) == []

    a, b = tee(irange(n))  # test 100% interleaved
    assert lzip(a, b) == lzip(range(n), range(n))

    a, b = tee(irange(n))  # test 0% interleaved
    assert list(a) == list(range(n))
    assert list(b) == list(range(n))

    a, b = tee(irange(n))  # test dealloc of leading iterator
    for i in range(100):
        assert next(a) == i
    assert list(b) == list(range(n))

    a, b = tee(irange(n))  # test dealloc of trailing iterator
    for i in range(100):
        assert next(a) == i
    assert list(a) == list(range(100, n))

    for j in range(5):  # test randomly interleaved
        order = [0] * n + [1] * n
        random.shuffle(order)
        lists = ([], [])
        its = tee(irange(n))
        for i in order:
            value = next(its[i])
            lists[i].append(value)
        assert lists[0] == list(range(n))
        assert lists[1] == list(range(n))

    # test long-lagged and multi-way split
    a, b, c = tee(range(2000), 3)
    for i in range(100):
        assert next(a) == i
    assert list(b) == list(range(2000))
    assert [next(c), next(c)] == list(range(2))
    assert list(a) == list(range(100, 2000))
    assert list(c) == list(range(2, 2000))


test_tee_from_cpython()