codon/test/core/bltin.codon

# Python-specific

@test
def test_min_max():
    neg = lambda x: -x

    assert min(42, 24) == 24
    assert max(42, 24) == 42
    assert min([42, 24]) == 24
    assert max([42, 24]) == 42
    assert min(1, 2, 3, 2, 1, 0, -1, 1, 2) == -1
    assert max(1, 2, 3, 2, 1, 0, -1, 1, 2) == 3
    assert min([1, 2, 3, 2, 1, 0, -1, 1, 2]) == -1
    assert max([1, 2, 3, 2, 1, 0, -1, 1, 2]) == 3

    assert min(42, 24, key=neg) == 42
    assert max(42, 24, key=neg) == 24
    assert min([42, 24], key=neg) == 42
    assert max([42, 24], key=neg) == 24
    assert min(1, 2, 3, 2, 1, 0, -1, 1, 2, key=neg) == 3
    assert max(1, 2, 3, 2, 1, 0, -1, 1, 2, key=neg) == -1
    assert min([1, 2, 3, 2, 1, 0, -1, 1, 2], key=neg) == 3
    assert max([1, 2, 3, 2, 1, 0, -1, 1, 2], key=neg) == -1

    assert min([42, 24], default=100) == 24
    assert max([42, 24], default=100) == 42
    assert min([1, 2, 3, 2, 1, 0, -1, 1, 2], default=100) == -1
    assert max([1, 2, 3, 2, 1, 0, -1, 1, 2], default=100) == 3

    assert min([42, 24], default=100, key=neg) == 42
    assert max([42, 24], default=100, key=neg) == 24
    assert min([1, 2, 3, 2, 1, 0, -1, 1, 2], default=100, key=neg) == 3
    assert max([1, 2, 3, 2, 1, 0, -1, 1, 2], default=100, key=neg) == -1

    assert max([2, 1, 1, 1, 1]) == 2
    assert max([1, 2, 1, 1, 1]) == 2
    assert max([1, 1, 2, 1, 1]) == 2
    assert max([1, 1, 1, 2, 1]) == 2
    assert max([1, 1, 1, 1, 2]) == 2
    assert max([2, 1, 1, 1]) == 2
    assert max([1, 2, 1, 1]) == 2
    assert max([1, 1, 2, 1]) == 2
    assert max([1, 1, 1, 2]) == 2
    assert max([2, 1, 1]) == 2
    assert max([1, 2, 1]) == 2
    assert max([1, 1, 2]) == 2
    assert max([2, 1]) == 2
    assert max([1, 2]) == 2

    assert max([2, 1, 1, 1, 1], key=neg) == 1
    assert max([1, 2, 1, 1, 1], key=neg) == 1
    assert max([1, 1, 2, 1, 1], key=neg) == 1
    assert max([1, 1, 1, 2, 1], key=neg) == 1
    assert max([1, 1, 1, 1, 2], key=neg) == 1
    assert max([2, 1, 1, 1], key=neg) == 1
    assert max([1, 2, 1, 1], key=neg) == 1
    assert max([1, 1, 2, 1], key=neg) == 1
    assert max([1, 1, 1, 2], key=neg) == 1
    assert max([2, 1, 1], key=neg) == 1
    assert max([1, 2, 1], key=neg) == 1
    assert max([1, 1, 2], key=neg) == 1
    assert max([2, 1], key=neg) == 1
    assert max([1, 2], key=neg) == 1

    assert min([2, 1, 1, 1, 1]) == 1
    assert min([1, 2, 1, 1, 1]) == 1
    assert min([1, 1, 2, 1, 1]) == 1
    assert min([1, 1, 1, 2, 1]) == 1
    assert min([1, 1, 1, 1, 2]) == 1
    assert min([2, 1, 1, 1]) == 1
    assert min([1, 2, 1, 1]) == 1
    assert min([1, 1, 2, 1]) == 1
    assert min([1, 1, 1, 2]) == 1
    assert min([2, 1, 1]) == 1
    assert min([1, 2, 1]) == 1
    assert min([1, 1, 2]) == 1
    assert min([2, 1]) == 1
    assert min([1, 2]) == 1

    assert min([2, 1, 1, 1, 1], key=neg) == 2
    assert min([1, 2, 1, 1, 1], key=neg) == 2
    assert min([1, 1, 2, 1, 1], key=neg) == 2
    assert min([1, 1, 1, 2, 1], key=neg) == 2
    assert min([1, 1, 1, 1, 2], key=neg) == 2
    assert min([2, 1, 1, 1], key=neg) == 2
    assert min([1, 2, 1, 1], key=neg) == 2
    assert min([1, 1, 2, 1], key=neg) == 2
    assert min([1, 1, 1, 2], key=neg) == 2
    assert min([2, 1, 1], key=neg) == 2
    assert min([1, 2, 1], key=neg) == 2
    assert min([1, 1, 2], key=neg) == 2
    assert min([2, 1], key=neg) == 2
    assert min([1, 2], key=neg) == 2

    assert max([0, 1, 1, 1, 1]) == 1
    assert max([1, 0, 1, 1, 1]) == 1
    assert max([1, 1, 0, 1, 1]) == 1
    assert max([1, 1, 1, 0, 1]) == 1
    assert max([1, 1, 1, 1, 0]) == 1
    assert max([0, 1, 1, 1]) == 1
    assert max([1, 0, 1, 1]) == 1
    assert max([1, 1, 0, 1]) == 1
    assert max([1, 1, 1, 0]) == 1
    assert max([0, 1, 1]) == 1
    assert max([1, 0, 1]) == 1
    assert max([1, 1, 0]) == 1
    assert max([0, 1]) == 1
    assert max([1, 0]) == 1

    assert max([0, 1, 1, 1, 1], key=neg) == 0
    assert max([1, 0, 1, 1, 1], key=neg) == 0
    assert max([1, 1, 0, 1, 1], key=neg) == 0
    assert max([1, 1, 1, 0, 1], key=neg) == 0
    assert max([1, 1, 1, 1, 0], key=neg) == 0
    assert max([0, 1, 1, 1], key=neg) == 0
    assert max([1, 0, 1, 1], key=neg) == 0
    assert max([1, 1, 0, 1], key=neg) == 0
    assert max([1, 1, 1, 0], key=neg) == 0
    assert max([0, 1, 1], key=neg) == 0
    assert max([1, 0, 1], key=neg) == 0
    assert max([1, 1, 0], key=neg) == 0
    assert max([0, 1], key=neg) == 0
    assert max([1, 0], key=neg) == 0

    assert min([0, 1, 1, 1, 1]) == 0
    assert min([1, 0, 1, 1, 1]) == 0
    assert min([1, 1, 0, 1, 1]) == 0
    assert min([1, 1, 1, 0, 1]) == 0
    assert min([1, 1, 1, 1, 0]) == 0
    assert min([0, 1, 1, 1]) == 0
    assert min([1, 0, 1, 1]) == 0
    assert min([1, 1, 0, 1]) == 0
    assert min([1, 1, 1, 0]) == 0
    assert min([0, 1, 1]) == 0
    assert min([1, 0, 1]) == 0
    assert min([1, 1, 0]) == 0
    assert min([0, 1]) == 0
    assert min([1, 0]) == 0

    assert min([0, 1, 1, 1, 1], key=neg) == 1
    assert min([1, 0, 1, 1, 1], key=neg) == 1
    assert min([1, 1, 0, 1, 1], key=neg) == 1
    assert min([1, 1, 1, 0, 1], key=neg) == 1
    assert min([1, 1, 1, 1, 0], key=neg) == 1
    assert min([0, 1, 1, 1], key=neg) == 1
    assert min([1, 0, 1, 1], key=neg) == 1
    assert min([1, 1, 0, 1], key=neg) == 1
    assert min([1, 1, 1, 0], key=neg) == 1
    assert min([0, 1, 1], key=neg) == 1
    assert min([1, 0, 1], key=neg) == 1
    assert min([1, 1, 0], key=neg) == 1
    assert min([0, 1], key=neg) == 1
    assert min([1, 0], key=neg) == 1

    assert min([0, 1, 1, 1, 1], default=99) == 0
    assert min([1, 0, 1, 1, 1], default=99) == 0
    assert min([1, 1, 0, 1, 1], default=99) == 0
    assert min([1, 1, 1, 0, 1], default=99) == 0
    assert min([1, 1, 1, 1, 0], default=99) == 0
    assert min([0, 1, 1, 1], default=99) == 0
    assert min([1, 0, 1, 1], default=99) == 0
    assert min([1, 1, 0, 1], default=99) == 0
    assert min([1, 1, 1, 0], default=99) == 0
    assert min([0, 1, 1], default=99) == 0
    assert min([1, 0, 1], default=99) == 0
    assert min([1, 1, 0], default=99) == 0
    assert min([0, 1], default=99) == 0
    assert min([1, 0], default=99) == 0
    assert min(List[int](), default=99) == 99

    assert min([0, 1, 1, 1, 1], key=neg, default=99) == 1
    assert min([1, 0, 1, 1, 1], key=neg, default=99) == 1
    assert min([1, 1, 0, 1, 1], key=neg, default=99) == 1
    assert min([1, 1, 1, 0, 1], key=neg, default=99) == 1
    assert min([1, 1, 1, 1, 0], key=neg, default=99) == 1
    assert min([0, 1, 1, 1], key=neg, default=99) == 1
    assert min([1, 0, 1, 1], key=neg, default=99) == 1
    assert min([1, 1, 0, 1], key=neg, default=99) == 1
    assert min([1, 1, 1, 0], key=neg, default=99) == 1
    assert min([0, 1, 1], key=neg, default=99) == 1
    assert min([1, 0, 1], key=neg, default=99) == 1
    assert min([1, 1, 0], key=neg, default=99) == 1
    assert min([0, 1], key=neg, default=99) == 1
    assert min([1, 0], key=neg, default=99) == 1
    assert min(List[int](), key=neg, default=99) == 99

    assert max([0, 1, 1, 1, 1], default=99) == 1
    assert max([1, 0, 1, 1, 1], default=99) == 1
    assert max([1, 1, 0, 1, 1], default=99) == 1
    assert max([1, 1, 1, 0, 1], default=99) == 1
    assert max([1, 1, 1, 1, 0], default=99) == 1
    assert max([0, 1, 1, 1], default=99) == 1
    assert max([1, 0, 1, 1], default=99) == 1
    assert max([1, 1, 0, 1], default=99) == 1
    assert max([1, 1, 1, 0], default=99) == 1
    assert max([0, 1, 1], default=99) == 1
    assert max([1, 0, 1], default=99) == 1
    assert max([1, 1, 0], default=99) == 1
    assert max([0, 1], default=99) == 1
    assert max([1, 0], default=99) == 1
    assert max(List[int](), default=99) == 99

    assert max([0, 1, 1, 1, 1], key=neg, default=99) == 0
    assert max([1, 0, 1, 1, 1], key=neg, default=99) == 0
    assert max([1, 1, 0, 1, 1], key=neg, default=99) == 0
    assert max([1, 1, 1, 0, 1], key=neg, default=99) == 0
    assert max([1, 1, 1, 1, 0], key=neg, default=99) == 0
    assert max([0, 1, 1, 1], key=neg, default=99) == 0
    assert max([1, 0, 1, 1], key=neg, default=99) == 0
    assert max([1, 1, 0, 1], key=neg, default=99) == 0
    assert max([1, 1, 1, 0], key=neg, default=99) == 0
    assert max([0, 1, 1], key=neg, default=99) == 0
    assert max([1, 0, 1], key=neg, default=99) == 0
    assert max([1, 1, 0], key=neg, default=99) == 0
    assert max([0, 1], key=neg, default=99) == 0
    assert max([1, 0], key=neg, default=99) == 0
    assert max(List[int](), key=neg, default=99) == 99

    assert max(2, 1, 1, 1, 1) == 2
    assert max(1, 2, 1, 1, 1) == 2
    assert max(1, 1, 2, 1, 1) == 2
    assert max(1, 1, 1, 2, 1) == 2
    assert max(1, 1, 1, 1, 2) == 2
    assert max(2, 1, 1, 1) == 2
    assert max(1, 2, 1, 1) == 2
    assert max(1, 1, 2, 1) == 2
    assert max(1, 1, 1, 2) == 2
    assert max(2, 1, 1) == 2
    assert max(1, 2, 1) == 2
    assert max(1, 1, 2) == 2
    assert max(2, 1) == 2
    assert max(1, 2) == 2

    assert max(2, 1, 1, 1, 1, key=neg) == 1
    assert max(1, 2, 1, 1, 1, key=neg) == 1
    assert max(1, 1, 2, 1, 1, key=neg) == 1
    assert max(1, 1, 1, 2, 1, key=neg) == 1
    assert max(1, 1, 1, 1, 2, key=neg) == 1
    assert max(2, 1, 1, 1, key=neg) == 1
    assert max(1, 2, 1, 1, key=neg) == 1
    assert max(1, 1, 2, 1, key=neg) == 1
    assert max(1, 1, 1, 2, key=neg) == 1
    assert max(2, 1, 1, key=neg) == 1
    assert max(1, 2, 1, key=neg) == 1
    assert max(1, 1, 2, key=neg) == 1
    assert max(2, 1, key=neg) == 1
    assert max(1, 2, key=neg) == 1

    assert min(2, 1, 1, 1, 1) == 1
    assert min(1, 2, 1, 1, 1) == 1
    assert min(1, 1, 2, 1, 1) == 1
    assert min(1, 1, 1, 2, 1) == 1
    assert min(1, 1, 1, 1, 2) == 1
    assert min(2, 1, 1, 1) == 1
    assert min(1, 2, 1, 1) == 1
    assert min(1, 1, 2, 1) == 1
    assert min(1, 1, 1, 2) == 1
    assert min(2, 1, 1) == 1
    assert min(1, 2, 1) == 1
    assert min(1, 1, 2) == 1
    assert min(2, 1) == 1
    assert min(1, 2) == 1

    assert min(2, 1, 1, 1, 1, key=neg) == 2
    assert min(1, 2, 1, 1, 1, key=neg) == 2
    assert min(1, 1, 2, 1, 1, key=neg) == 2
    assert min(1, 1, 1, 2, 1, key=neg) == 2
    assert min(1, 1, 1, 1, 2, key=neg) == 2
    assert min(2, 1, 1, 1, key=neg) == 2
    assert min(1, 2, 1, 1, key=neg) == 2
    assert min(1, 1, 2, 1, key=neg) == 2
    assert min(1, 1, 1, 2, key=neg) == 2
    assert min(2, 1, 1, key=neg) == 2
    assert min(1, 2, 1, key=neg) == 2
    assert min(1, 1, 2, key=neg) == 2
    assert min(2, 1, key=neg) == 2
    assert min(1, 2, key=neg) == 2

    assert max(0, 1, 1, 1, 1) == 1
    assert max(1, 0, 1, 1, 1) == 1
    assert max(1, 1, 0, 1, 1) == 1
    assert max(1, 1, 1, 0, 1) == 1
    assert max(1, 1, 1, 1, 0) == 1
    assert max(0, 1, 1, 1) == 1
    assert max(1, 0, 1, 1) == 1
    assert max(1, 1, 0, 1) == 1
    assert max(1, 1, 1, 0) == 1
    assert max(0, 1, 1) == 1
    assert max(1, 0, 1) == 1
    assert max(1, 1, 0) == 1
    assert max(0, 1) == 1
    assert max(1, 0) == 1

    assert max(0, 1, 1, 1, 1, key=neg) == 0
    assert max(1, 0, 1, 1, 1, key=neg) == 0
    assert max(1, 1, 0, 1, 1, key=neg) == 0
    assert max(1, 1, 1, 0, 1, key=neg) == 0
    assert max(1, 1, 1, 1, 0, key=neg) == 0
    assert max(0, 1, 1, 1, key=neg) == 0
    assert max(1, 0, 1, 1, key=neg) == 0
    assert max(1, 1, 0, 1, key=neg) == 0
    assert max(1, 1, 1, 0, key=neg) == 0
    assert max(0, 1, 1, key=neg) == 0
    assert max(1, 0, 1, key=neg) == 0
    assert max(1, 1, 0, key=neg) == 0
    assert max(0, 1, key=neg) == 0
    assert max(1, 0, key=neg) == 0

    assert min(0, 1, 1, 1, 1) == 0
    assert min(1, 0, 1, 1, 1) == 0
    assert min(1, 1, 0, 1, 1) == 0
    assert min(1, 1, 1, 0, 1) == 0
    assert min(1, 1, 1, 1, 0) == 0
    assert min(0, 1, 1, 1) == 0
    assert min(1, 0, 1, 1) == 0
    assert min(1, 1, 0, 1) == 0
    assert min(1, 1, 1, 0) == 0
    assert min(0, 1, 1) == 0
    assert min(1, 0, 1) == 0
    assert min(1, 1, 0) == 0
    assert min(0, 1) == 0
    assert min(1, 0) == 0

    assert min(0, 1, 1, 1, 1, key=neg) == 1
    assert min(1, 0, 1, 1, 1, key=neg) == 1
    assert min(1, 1, 0, 1, 1, key=neg) == 1
    assert min(1, 1, 1, 0, 1, key=neg) == 1
    assert min(1, 1, 1, 1, 0, key=neg) == 1
    assert min(0, 1, 1, 1, key=neg) == 1
    assert min(1, 0, 1, 1, key=neg) == 1
    assert min(1, 1, 0, 1, key=neg) == 1
    assert min(1, 1, 1, 0, key=neg) == 1
    assert min(0, 1, 1, key=neg) == 1
    assert min(1, 0, 1, key=neg) == 1
    assert min(1, 1, 0, key=neg) == 1
    assert min(0, 1, key=neg) == 1
    assert min(1, 0, key=neg) == 1

    assert min(a*a for a in range(3)) == 0
    assert max(a*a for a in range(3)) == 4
    assert min([0, 2, -1]) == -1
    assert max([0, 2, -1]) == 2

    assert min((a*a for a in range(3)), key=neg) == 4
    assert max((a*a for a in range(3)), key=neg) == 0
    assert min([0, 2, -1], key=neg) == 2
    assert max([0, 2, -1], key=neg) == -1

    assert min('abcx') == 'a'
    assert max('abcx') == 'x'
    assert min(['a', 'b', 'c', 'x']) == 'a'
    assert max(['a', 'b', 'c', 'x']) == 'x'

    d = {'a': 4, 'b': 1, 'c': -1, 'x': 9}
    assert min('abcx', key=d.__getitem__) == 'c'
    assert max('abcx', key=d.__getitem__) == 'x'
    assert min(['a', 'b', 'c', 'x'], key=d.__getitem__) == 'c'
    assert max(['a', 'b', 'c', 'x'], key=d.__getitem__) == 'x'

    try:
        max('')
        assert False
    except ValueError as e:
        assert str(e) == 'max() arg is an empty sequence'

    try:
        min('')
        assert False
    except ValueError as e:
        assert str(e) == 'min() arg is an empty sequence'

    try:
        max(List[float]())
        assert False
    except ValueError as e:
        assert str(e) == 'max() arg is an empty sequence'

    try:
        min(List[float]())
        assert False
    except ValueError as e:
        assert str(e) == 'min() arg is an empty sequence'

    try:
        max('', key=lambda x: x * 2)
        assert False
    except ValueError as e:
        assert str(e) == 'max() arg is an empty sequence'

    try:
        min('', key=lambda x: x * 2)
        assert False
    except ValueError as e:
        assert str(e) == 'min() arg is an empty sequence'

    try:
        max(List[float](), key=lambda x: x * 2)
        assert False
    except ValueError as e:
        assert str(e) == 'max() arg is an empty sequence'

    try:
        min(List[float](), key=lambda x: x * 2)
        assert False
    except ValueError as e:
        assert str(e) == 'min() arg is an empty sequence'

@test
def test_map_filter():
    assert list(map(lambda i: i+1, (i*2 for i in range(5)))) == [1, 3, 5, 7, 9]
    assert list(map(lambda i: i+1, (i*2 for i in range(0)))) == []
    assert list(map(lambda i: i//2, map(lambda i: i-1, map(lambda i: i+1, (i*2 for i in range(5)))))) == [0, 1, 2, 3, 4]
    def f(x: int) -> int:
        return x - 1
    def g(x: int) -> int:
        return x + 1
    assert list(map(f, map(g, (i*2 for i in range(5))))) == [0, 2, 4, 6, 8]

    def h(x: list[int]):
        return x
    assert h(list(map(lambda i: i-1, map(lambda i: i+1, range(5))))) == [0, 1, 2, 3, 4]

    assert list(filter(lambda i: i % 2 == 0, range(5))) == [0, 2, 4]
    assert list(filter(lambda i: i % 2 == 1, filter(lambda i: i % 2 == 0, range(5)))) == []

    assert list(filter(lambda i: i%2 == 0, map(lambda i: i*i, range(10)))) == [0, 4, 16, 36, 64]

@test
def test_gen_builtins():
    assert sum([1, 2, 3]) == 6
    assert sum([1, 2, 3], 0.5) == 6.5
    assert sum([True, False, True, False, True], 0.5) == 3.5
    assert sum(List[float]()) == 0
    assert sum(i/2 for i in range(10)) == 22.5

    def g1():
        yield 1.5
        yield 2.5
        return
        yield 3.5

    assert sum(g1(), 10) == 14.0

    def g2():
        yield True
        yield False
        yield True

    assert sum(g2()) == 2

    class A:
        iadd_count = 0
        n: int

        def __init__(self, n):
            self.n = n

        def __add__(self, other):
            return A(self.n + other.n)

        def __iadd__(self, other):
            A.iadd_count += 1
            self.n += other.n
            return self

    assert sum((A(i) for i in range(5)), A(100)).n == 110
    assert A.iadd_count == 0

    def g3(a, b):
        for i in range(10):
            yield a
        yield b

    assert all([True, True])
    assert all(i for i in range(0))
    assert not all([True, False])
    assert all(List[str]())
    assert all(g3(True, True))
    assert not all(g3(True, False))
    assert not all(g3(False, True))
    assert not all(g3(False, False))

    assert any([True, True])
    assert not any(i for i in range(0))
    assert not any([False, False])
    assert not any(List[bool]())
    assert any(g3(True, True))
    assert any(g3(True, False))
    assert any(g3(False, True))
    assert not any(g3(False, False))

@test
def test_int_format():
    n = 0
    assert (str(n), bin(n), oct(n), hex(n)) == ('0', '0b0', '0o0', '0x0')

    n = -1
    assert (str(n), bin(n), oct(n), hex(n)) == ('-1', '-0b1', '-0o1', '-0x1')

    n = 12345
    assert (str(n), bin(n), oct(n), hex(n)) == ('12345', '0b11000000111001', '0o30071', '0x3039')

    n = -12345
    assert (str(n), bin(n), oct(n), hex(n)) == ('-12345', '-0b11000000111001', '-0o30071', '-0x3039')

    # this one is different than Python due to 64-bit ints
    n = 0x8000000000000000
    assert (str(n), bin(n), oct(n), hex(n)) == ('-9223372036854775808', '-0b1000000000000000000000000000000000000000000000000000000000000000', '-0o1000000000000000000000', '-0x8000000000000000')

    n = 0x7fffffffffffffff
    assert (str(n), bin(n), oct(n), hex(n)) == ('9223372036854775807', '0b111111111111111111111111111111111111111111111111111111111111111', '0o777777777777777777777', '0x7fffffffffffffff')

    m = i32(0)
    assert (str(m), bin(m), oct(m), hex(m)) == ('0', '0b0', '0o0', '0x0')

    m = i32(-1)
    assert (str(m), bin(m), oct(m), hex(m)) == ('-1', '-0b1', '-0o1', '-0x1')

    m = i32(12345)
    assert (str(m), bin(m), oct(m), hex(m)) == ('12345', '0b11000000111001', '0o30071', '0x3039')

    m = i32(-12345)
    assert (str(m), bin(m), oct(m), hex(m)) == ('-12345', '-0b11000000111001', '-0o30071', '-0x3039')

    k = Int[128](0)
    assert (str(k), bin(k), oct(k), hex(k)) == ('0', '0b0', '0o0', '0x0')

    k = Int[128](-1)
    assert (str(k), bin(k), oct(k), hex(k)) == ('-1', '-0b1', '-0o1', '-0x1')

    k = Int[128](12345)
    assert (str(k), bin(k), oct(k), hex(k)) == ('12345', '0b11000000111001', '0o30071', '0x3039')

    k = Int[128](-12345)
    assert (str(k), bin(k), oct(k), hex(k)) == ('-12345', '-0b11000000111001', '-0o30071', '-0x3039')

    # this one is different than Python due to 64-bit ints
    k = Int[128](0x8000000000000000)
    assert (str(k), bin(k), oct(k), hex(k)) == ('-9223372036854775808', '-0b1000000000000000000000000000000000000000000000000000000000000000', '-0o1000000000000000000000', '-0x8000000000000000')

    k = Int[128](0x7fffffffffffffff)
    assert (str(k), bin(k), oct(k), hex(k)) == ('9223372036854775807', '0b111111111111111111111111111111111111111111111111111111111111111', '0o777777777777777777777', '0x7fffffffffffffff')

@test
def test_complex_format():
    import math

    assert str(complex(1.1, 2.2)) == '(1.1+2.2j)'
    assert str(complex(11.0, -22.0)) == '(11-22j)'
    assert str(complex(-111.0, 222.0)) == '(-111+222j)'
    assert str(complex(-1111.0, -2222.0)) == '(-1111-2222j)'
    assert str(complex(1.0, 0.0)) == '(1+0j)'
    assert str(complex(0.0, 1.0)) == '1j'
    assert str(complex(-0.0, 1.0)) == '(-0+1j)'
    assert str(complex(0.0, -1.0)) == '-1j'
    assert str(complex(-0.0, -1.0)) == '(-0-1j)'
    assert str(complex(0.0, 0.0)) == '0j'
    assert str(complex(0.0, -0.0)) == '-0j'
    assert str(complex(-0.0, 0.0)) == '(-0+0j)'
    assert str(complex(-0.0, -0.0)) == '(-0-0j)'
    assert str(complex(math.inf, math.inf)) == '(inf+infj)'
    assert str(complex(-math.inf, math.nan)) == '(-inf+nanj)'
    assert str(complex(math.nan, -math.inf)) == '(nan-infj)'
    assert str(complex(math.nan, math.nan)) == '(nan+nanj)'

    assert repr(complex(1.1, 2.2)) == '(1.1+2.2j)'
    assert repr(complex(11.0, -22.0)) == '(11-22j)'
    assert repr(complex(-111.0, 222.0)) == '(-111+222j)'
    assert repr(complex(-1111.0, -2222.0)) == '(-1111-2222j)'
    assert repr(complex(1.0, 0.0)) == '(1+0j)'
    assert repr(complex(0.0, 1.0)) == '1j'
    assert repr(complex(-0.0, 1.0)) == '(-0+1j)'
    assert repr(complex(0.0, -1.0)) == '-1j'
    assert repr(complex(-0.0, -1.0)) == '(-0-1j)'
    assert repr(complex(0.0, 0.0)) == '0j'
    assert repr(complex(0.0, -0.0)) == '-0j'
    assert repr(complex(-0.0, 0.0)) == '(-0+0j)'
    assert repr(complex(-0.0, -0.0)) == '(-0-0j)'
    assert repr(complex(math.inf, math.inf)) == '(inf+infj)'
    assert repr(complex(-math.inf, math.nan)) == '(-inf+nanj)'
    assert repr(complex(math.nan, -math.inf)) == '(nan-infj)'
    assert repr(complex(math.nan, math.nan)) == '(nan+nanj)'

    assert str(complex64(1.1, 2.2)) == '(1.1+2.2j)'
    assert str(complex64(11.0, -22.0)) == '(11-22j)'
    assert str(complex64(-111.0, 222.0)) == '(-111+222j)'
    assert str(complex64(-1111.0, -2222.0)) == '(-1111-2222j)'
    assert str(complex64(1.0, 0.0)) == '(1+0j)'
    assert str(complex64(0.0, 1.0)) == '1j'
    assert str(complex64(-0.0, 1.0)) == '(-0+1j)'
    assert str(complex64(0.0, -1.0)) == '-1j'
    assert str(complex64(-0.0, -1.0)) == '(-0-1j)'
    assert str(complex64(0.0, 0.0)) == '0j'
    assert str(complex64(0.0, -0.0)) == '-0j'
    assert str(complex64(-0.0, 0.0)) == '(-0+0j)'
    assert str(complex64(-0.0, -0.0)) == '(-0-0j)'
    assert str(complex64(math.inf, math.inf)) == '(inf+infj)'
    assert str(complex64(-math.inf, math.nan)) == '(-inf+nanj)'
    assert str(complex64(math.nan, -math.inf)) == '(nan-infj)'
    assert str(complex64(math.nan, math.nan)) == '(nan+nanj)'

    assert repr(complex64(1.1, 2.2)) == 'complex64(1.1+2.2j)'
    assert repr(complex64(11.0, -22.0)) == 'complex64(11-22j)'
    assert repr(complex64(-111.0, 222.0)) == 'complex64(-111+222j)'
    assert repr(complex64(-1111.0, -2222.0)) == 'complex64(-1111-2222j)'
    assert repr(complex64(1.0, 0.0)) == 'complex64(1+0j)'
    assert repr(complex64(0.0, 1.0)) == 'complex64(1j)'
    assert repr(complex64(-0.0, 1.0)) == 'complex64(-0+1j)'
    assert repr(complex64(0.0, -1.0)) == 'complex64(-1j)'
    assert repr(complex64(-0.0, -1.0)) == 'complex64(-0-1j)'
    assert repr(complex64(0.0, 0.0)) == 'complex64(0j)'
    assert repr(complex64(0.0, -0.0)) == 'complex64(-0j)'
    assert repr(complex64(-0.0, 0.0)) == 'complex64(-0+0j)'
    assert repr(complex64(-0.0, -0.0)) == 'complex64(-0-0j)'
    assert repr(complex64(math.inf, math.inf)) == 'complex64(inf+infj)'
    assert repr(complex64(-math.inf, math.nan)) == 'complex64(-inf+nanj)'
    assert repr(complex64(math.nan, -math.inf)) == 'complex64(nan-infj)'
    assert repr(complex64(math.nan, math.nan)) == 'complex64(nan+nanj)'

@test
def test_alt_types_from_str():
    assert float32('3.14') == float32(3.14)
    # TODO: fails on manylinux w/ "Symbols not found: [ __truncdfhf2, __extendhfsf2 ]"
    # assert float16('3.14') == float16(3.14)
    assert complex64('1+2j') == complex64(1+2j)

class A:
    def __len__(self):
        return 42
    def __getitem__(self, idx):
        return idx

@test
def test_reversed():
    assert list(reversed([1,2,3])) == [3,2,1]
    assert list(reversed('abc')) == ['c','b','a']
    assert list(reversed('')) == []
    assert list(reversed(A())) == list(reversed(range(42)))

@test
def test_divmod():
    import sys, math
    assert divmod(12, 7) == (1, 5)
    assert divmod(-12, 7) == (-2, 2)
    assert divmod(12, -7) == (-2, -2)
    assert divmod(-12, -7) == (1, -5)

    assert divmod(i32(12), i32(7)) == (i32(1), i32(5))
    assert divmod(i32(-12), i32(7)) == (i32(-2), i32(2))
    assert divmod(i32(12), i32(-7)) == (i32(-2), i32(-2))
    assert divmod(i32(-12), i32(-7)) == (i32(1), i32(-5))

    assert divmod(u32(12), u32(7)) == (u32(1), u32(5))

    i128 = Int[128]
    assert divmod(i128(12), i128(7)) == (i128(1), i128(5))
    assert divmod(i128(-12), i128(7)) == (i128(-2), i128(2))
    assert divmod(i128(12), i128(-7)) == (i128(-2), i128(-2))
    assert divmod(i128(-12), i128(-7)) == (i128(1), i128(-5))

    class X:
        n: int
        def __floordiv__(self, other: X):
            return X(self.n // other.n)
        def __mod__(self, other: X):
            return X(self.n % other.n)
        def __eq__(self, other: X):
            return self.n == other.n
        def __nq__(self, other: X):
            return self.n != other.n
    assert divmod(X(12), X(7)) == (X(1), X(5))

    # following is invalid in our case due to 64-bit ints
    # print divmod(-sys.maxsize-1, -1), (sys.maxsize+1, 0)

    for num, denom, exp_result in [ (3.25, 1.0, (3.0, 0.25)),
                                    (-3.25, 1.0, (-4.0, 0.75)),
                                    (3.25, -1.0, (-4.0, -0.75)),
                                    (-3.25, -1.0, (3.0, -0.25))]:
        result = divmod(num, denom)
        assert math.isclose(result[0], exp_result[0])
        assert math.isclose(result[1], exp_result[1])

@test
def test_pow():
    assert pow(3, 4) == 81
    assert pow(-3, 3) == -27
    assert pow(1, 0) == 1
    assert pow(-1, 0) == 1
    assert pow(0, 0) == 1
    assert pow(12, 12, 42) == 36
    assert pow(1234, 4321, 99) == 46
    assert pow(9999, 9999, 2) == 1
    assert pow(0, 0, 1) == 0

    try:
        pow(1, -1, 2)
        assert False
    except ValueError as e:
        assert 'negative' in str(e)

    try:
        pow(1, 1, 0)
        assert False
    except ValueError as e:
        assert 'cannot be 0' in str(e)

    assert pow(1.5, 2) == 2.25
    assert pow(9, 0.5) == 3.0
    assert pow(2.0, -1.0) == 0.5

@test
def test_num_from_str():
    import math

    assert int('0') == 0
    assert int('010') == 10
    assert int('3\n') == 3
    assert int('\r\t\n 42\r\t\n ') == 42
    assert int('0101', 2) == 5
    assert int('-0101', 2) == -5
    assert int('0111', 8) == 73
    assert int('-0111', 8) == -73
    assert int('-0xabc', 16) == -2748
    assert int('0xabc', 16) == 2748
    assert int('-0xabc', 16) == -2748
    assert int('111', 0) == 111
    assert int('-111', 0) == -111
    assert int('-0xabc', 0) == -2748
    assert int('0xabc', 0) == 2748
    assert int('-0xabc', 0) == -2748

    try:
        int('  10  a')
        assert False
    except ValueError as e:
        assert str(e) == "invalid literal for int() with base 10: '  10  a'"

    try:
        int('')
        assert False
    except ValueError as e:
        assert str(e) == "invalid literal for int() with base 10: ''"

    # new tests for PR #561
    assert int("123") == 123
    assert int("-123") == -123
    assert int("+123") == 123
    assert int("0") == 0
    assert int("-0") == 0
    assert int("0000123") == 123
    assert int("-0000123") == -123
    assert int("+0000123") == 123
    assert int("123 ") == 123
    assert int(" 123") == 123
    assert int(" 123 ") == 123

    assert int("1101", 2) == 13
    assert int("-1101", 2) == -13
    assert int("+1101", 2) == 13
    assert int("0b1101", 2) == 13
    assert int("-0b1101", 2) == -13
    assert int("+0b1101", 2) == 13
    assert int("00001101", 2) == 13
    assert int("-00001101", 2) == -13
    assert int("0", 2) == 0

    assert int("123", 8) == 83
    assert int("-123", 8) == -83
    assert int("+123", 8) == 83
    assert int("0o123", 8) == 83
    assert int("-0o123", 8) == -83
    assert int("+0o123", 8) == 83
    assert int("0000123", 8) == 83
    assert int("-0000123", 8) == -83
    assert int("0", 8) == 0

    assert int("1A", 16) == 26
    assert int("-1A", 16) == -26
    assert int("+1A", 16) == 26
    assert int("0x1A", 16) == 26
    assert int("-0x1A", 16) == -26
    assert int("+0x1A", 16) == 26
    assert int("00001A", 16) == 26
    assert int("-00001A", 16) == -26
    assert int("0", 16) == 0

    assert int("Z", 36) == 35
    assert int("-Z", 36) == -35
    assert int("+Z", 36) == 35
    assert int("0", 36) == 0
    assert int("10", 36) == 36
    assert int("000Z", 36) == 35
    assert int("-000Z", 36) == -35
    assert int("+000Z", 36) == 35

    assert int("123", 0) == 123
    assert int("-123", 0) == -123
    assert int("+123", 0) == 123
    assert int("0b1101", 0) == 13
    assert int("-0b1101", 0) == -13
    assert int("+0b1101", 0) == 13
    assert int("0o123", 0) == 83
    assert int("-0o123", 0) == -83
    assert int("+0o123", 0) == 83
    assert int("0x1A", 0) == 26
    assert int("-0x1A", 0) == -26
    assert int(" +0x1a\n", 0) == 26

    try:
        int("1A", 10)
        assert False
    except ValueError:
        pass

    try:
        int("0b1101", 10)
        assert False
    except ValueError:
        pass

    try:
        int("0o123", 10)
        assert False
    except ValueError:
        pass

    try:
        int("0x1A", 10)
        assert False
    except ValueError:
        pass

    try:
        int("Z", 10)
        assert False
    except ValueError:
        pass

    try:
        int("123", 1)
        assert False
    except ValueError:
        pass

    try:
        int("123", 37)
        assert False
    except ValueError:
        pass

    try:
        int("123", -10)
        assert False
    except ValueError:
        pass

    assert int("\n123\n") == 123
    assert int("\t123\t") == 123
    assert int("   123   ") == 123
    assert int("+0x7FFFFFFF", 0) == 0x7FFFFFFF
    assert int("-0x80000000", 0) == -0x80000000
    assert int("+0o37777777777", 0) == 4294967295  # 0o37777777777
    assert int("-0o40000000000", 0) == -4294967296  # -0o40000000000
    assert int("+0b1111111111111111111111111111111", 0) == 0b1111111111111111111111111111111
    assert int("-0b10000000000000000000000000000000", 0) == -0b10000000000000000000000000000000

    assert float('0') == 0
    assert float('3.14') == 3.14
    assert float('3\n') == 3
    assert float('\r\t\n -4.2\r\t\n ') == -4.2
    assert math.isnan(float(' nan '))
    assert math.isnan(float(' +nan '))
    assert math.isnan(float(' -nan '))
    assert math.isinf(float(' inf '))
    assert math.isinf(float(' +inf '))
    assert math.isinf(float(' -inf '))
    assert math.isinf(float(' infinity '))
    assert math.isinf(float(' +infinity '))
    assert math.isinf(float(' -infinity '))
    assert float(' inf ') > 0.0
    assert float(' +inf ') > 0.0
    assert float(' -inf ') < 0.0
    assert float(' infinity ') > 0.0
    assert float(' +infinity ') > 0.0
    assert float(' -infinity ') < 0.0

    try:
        float('  3.14  a')
        assert False
    except ValueError as e:
        assert str(e) == "could not convert string to float: '  3.14  a'"

    try:
        float('')
        assert False
    except ValueError as e:
        assert str(e) == "could not convert string to float: ''"

@test
def test_files(open_fn, append_allowed: bool = True):
    path = 'build/testfile.txt'
    f = open_fn(path, 'w')
    f.write('hello\nworld\n')
    f.close()

    with open_fn(path) as f:
        assert [line for line in f] == ['hello\n', 'world\n']

    with open_fn(path) as f:
        assert f.read(3) == 'hel'
        assert f.read() == 'lo\nworld\n'
        if hasattr(f, "seek"):
            f.seek(0, 0)
            assert f.tell() == 0
            assert f.read() == 'hello\nworld\n'

    if hasattr(f, "tell"):
        try:
            f.tell()
            assert False
        except IOError:
            pass

    if hasattr(f, "seek"):
        try:
            f.seek(0, 0)
            assert False
        except IOError:
            pass

    try:
        f.flush()
        assert False
    except IOError:
        pass

    if append_allowed:
        f = open_fn(path, 'a')
        f.write('goodbye')
        f.flush()
        f.close()
    else:
        f = open_fn(path, 'w')
        f.write('hello\nworld\ngoodbye')
        f.flush()
        f.close()

    with open_fn(path) as f:
        assert [line for line in f] == ['hello\n', 'world\n', 'goodbye']

    with open_fn(path) as f:
        assert f.read(3) == 'hel'
        assert f.read() == 'lo\nworld\ngoodbye'

test_min_max()
test_map_filter()
test_gen_builtins()
test_int_format()
test_complex_format()
test_alt_types_from_str()
test_reversed()
test_divmod()
test_pow()
test_num_from_str()
test_files(open)
import gzip
test_files(gzip.open)
import bz2
test_files(bz2.open, append_allowed=False)


# Codon-specific

@pure
@llvm
def zext(x: int, T: type) -> T:
    %0 = zext i64 %x to {=T}
    ret {=T} %0

@test
def test_narrow_int_str(T: type):
    z = T(0)
    o = T(1)
    a = T(42)
    b = T(-9)

    assert str(z) == '0'
    assert str(-z) == '0'
    assert str(o) == '1'
    assert str(-o) == '-1'
    assert str(o + o + o) == '3'
    assert str((o + o + o + o) * (o + o + o)) == '12'
    assert str(a) == '42'
    assert str(b) == '-9'
    assert repr(a) == f'Int[{T.N}](42)'

@test
def test_narrow_uint_str(T: type):
    z = T(0)
    o = T(1)
    a = T(42)

    assert str(z) == '0'
    assert str(-z) == '0'
    assert str(o) == '1'
    assert str(o + o + o) == '3'
    assert str((o + o + o + o) * (o + o + o)) == '12'
    assert str(a) == '42'

    if T.N == 32:
        assert str(T(0xffffffff)) == '4294967295'

    if T.N == 64:
        assert str(T(0xffffffffffffffff)) == '18446744073709551615'

    assert repr(a) == f'UInt[{T.N}](42)'

@test
def test_wide_int_str(T: type):
    z = T(0)
    o = T(1)
    a = T(0xf23ff2341234)
    b = T(-77777)

    assert str(z) == '0'
    assert str(-z) == '0'
    assert str(o) == '1'
    assert str(-o) == '-1'
    assert str(o + o + o) == '3'
    assert str((o + o + o + o) * (o + o + o)) == '12'
    assert str(a) == '266356460360244'
    assert str(b) == '-77777'
    assert str(a * a) == '70945763975638233282255739536'
    assert str(b * b) == '6049261729'
    assert str(a * b) == '-20716406417438697588'

    n = zext(0x7fffffffffffffff, T)
    m = zext(0xffffffffffffffff, T)
    s = T(64)
    assert str((n << s) | m) == '170141183460469231731687303715884105727'
    if T.N == 128:
        assert str(T(1) << T(127)) == '-170141183460469231731687303715884105728'
    if T.N > 500:
        assert str(a * a * a * a * a * a * a * a) == '25334123245849102734940743817373556303530349383588924760280652082676453679304226528003335153202090430651964934127616'
        assert str(a * a * a * a * a * a * a * a * b) == '-1970412103692405663415486231883863088619679984007395801080348277034326537815244826668515398210598987424817876681643589632'

    assert repr(a) == f'Int[{T.N}](266356460360244)'
    assert repr(a * b) == f'Int[{T.N}](-20716406417438697588)'

@test
def test_wide_uint_str(T: type):
    z = T(0)
    o = T(1)
    a = T(0xf23ff2341234)

    assert str(z) == '0'
    assert str(-z) == '0'
    assert str(o) == '1'
    assert str(o + o + o) == '3'
    assert str((o + o + o + o) * (o + o + o)) == '12'
    assert str(a) == '266356460360244'
    assert str(a * a) == '70945763975638233282255739536'

    n = zext(0xffffffffffffffff, T)
    s = T(64)
    assert str((n << s) | n) == '340282366920938463463374607431768211455'
    assert str((n << s) | (n - T(1))) == '340282366920938463463374607431768211454'
    if T.N > 500:
        assert str(a * a * a * a * a * a * a * a) == '25334123245849102734940743817373556303530349383588924760280652082676453679304226528003335153202090430651964934127616'

    assert repr(a) == f'UInt[{T.N}](266356460360244)'
    assert repr(a * a) == f'UInt[{T.N}](70945763975638233282255739536)'

test_narrow_int_str(Int[7])
test_narrow_int_str(Int[8])
test_narrow_int_str(Int[10])
test_narrow_int_str(Int[16])
test_narrow_int_str(Int[32])
test_narrow_int_str(Int[60])
test_narrow_int_str(Int[63])
test_narrow_int_str(Int[64])

test_narrow_uint_str(UInt[7])
test_narrow_uint_str(UInt[8])
test_narrow_uint_str(UInt[10])
test_narrow_uint_str(UInt[16])
test_narrow_uint_str(UInt[32])
test_narrow_uint_str(UInt[60])
test_narrow_uint_str(UInt[63])
test_narrow_uint_str(UInt[64])

test_wide_int_str(Int[128])
test_wide_int_str(Int[200])
test_wide_int_str(Int[256])
test_wide_int_str(Int[512])
test_wide_int_str(Int[1024])
test_wide_int_str(Int[2048])
test_wide_int_str(Int[4096])

test_wide_uint_str(UInt[128])
test_wide_uint_str(UInt[200])
test_wide_uint_str(UInt[256])
test_wide_uint_str(UInt[512])
test_wide_uint_str(UInt[1024])
test_wide_uint_str(UInt[2048])
test_wide_uint_str(UInt[4096])