-- Test cases for Python 3.8 features

[case testWalrus1]
from typing import Optional

def foo(x: int) -> Optional[int]:
    if x < 0:
        return None
    return x

def test(x: int) -> str:
    if (n := foo(x)) is not None:
        return str(x)
    else:
        return "<fail>"

[file driver.py]
from native import test

assert test(10) == "10"
assert test(-1) == "<fail>"


[case testWalrus2]
from typing import Optional, Tuple, List

class Node:
    def __init__(self, val: int, next: Optional['Node']) -> None:
        self.val = val
        self.next = next

def pairs(nobe: Optional[Node]) -> List[Tuple[int, int]]:
    if nobe is None:
        return []
    l = []
    while next := nobe.next:
        l.append((nobe.val, next.val))
        nobe = next
    return l

def make(l: List[int]) -> Optional[Node]:
    cur: Optional[Node] = None
    for x in reversed(l):
        cur = Node(x, cur)
    return cur

[file driver.py]
from native import Node, make, pairs

assert pairs(make([1,2,3])) == [(1,2), (2,3)]
assert pairs(make([1])) == []
assert pairs(make([])) == []

[case testWalrusEvaluationOrder]
from typing import Any, Callable, Dict, Iterator, Tuple

from mypy_extensions import i64

from testutil import assertRaises

def pair(a: object, b: object) -> Tuple[object, object]:
    return a, b

def pair_int(a: int, b: int = 5) -> Tuple[int, int]:
    return a, b

def collect(*args: object, **kwargs: object) -> Tuple[Tuple[object, ...], Dict[str, object]]:
    return args, kwargs

class C:
    def __init__(self, x: int, y: int = 0) -> None:
        self.x = x
        self.y = y

    def method(self, a: int, b: int) -> Tuple[int, int, int]:
        return self.x, a, b

def test_call_arguments() -> None:
    i = 0
    assert pair(i, (i := 1)) == (0, 1)
    assert pair_int(i, (i := 2)) == (1, 2)
    assert pair_int(b=i, a=(i := 3)) == (3, 2)
    assert collect(i, (i := i + 1), i, (i := i + 1), i) == ((3, 4, 4, 5, 5), {})
    s = "old"
    assert pair(s, (s := "new")) == ("old", "new")
    x = 1.5
    assert pair(x, (x := 2.5)) == (1.5, 2.5)
    n: i64 = 1
    assert pair(n, (n := 2)) == (1, 2)
    a = 1
    b = 2
    assert pair((a := b), (b := 3)) == (2, 3)

def reassign_args(i: int, s: str) -> Tuple[object, object]:
    return pair(i, (i := 1)), pair(s, (s := "new"))

def test_function_arguments() -> None:
    assert reassign_args(0, "old") == ((0, 1), ("old", "new"))

def test_python_call_arguments() -> None:
    f: Any = pair
    i = 0
    assert f(i, (i := 1)) == (0, 1)
    assert divmod(i, (i := 3)) == (0, 1)
    assert max(i, (i := 0)) == 3

def test_star_arguments() -> None:
    t: Tuple[int, ...] = (1, 2)
    assert collect(*t, (t := (3,))) == ((1, 2, (3,)), {})
    d: Dict[str, object] = {"a": 1}
    assert collect(**d, b=(d := {"c": 2})) == ((), {"a": 1, "b": {"c": 2}})

def test_method_calls() -> None:
    i = 0
    c = C(i, (i := 1))
    assert (c.x, c.y) == (0, 1)
    assert c.method(i, (i := 2)) == (0, 1, 2)
    assert c.method(i, (c := C(5)).x) == (0, 2, 5)
    a = [1]
    a.append((a := [2])[0])
    assert a == [2]
    sep = ","
    assert sep.join(["a", (sep := "-")]) == "a,-"

def old(x: object) -> str:
    return "old"

def new(x: object) -> str:
    return "new"

def test_callee() -> None:
    f: Callable[[object], str] = old
    assert f((f := new)) == "old"
    assert f(0) == "new"

def test_operators_and_displays() -> None:
    i = 1
    assert i - (i := 3) == -2
    assert (i <= (i := 0)) is False
    x = 1.5
    assert x + (x := 2.0) == 3.5
    n: i64 = 1
    assert n - (n := 5) == -4
    s = "a"
    assert s + (s := "b") == "ab"
    assert [i, (i := 1)] == [0, 1]
    assert sorted({i, (i := 2)}) == [1, 2]
    assert {i: (i := 3)} == {2: 3}
    assert (i, *[(i := 4)]) == (3, 4)
    items = [10, 20]
    assert items[len(items := [30, 40]) - 1] == 20

def test_comprehension() -> None:
    y = -1
    assert [pair(y, (y := x)) for x in range(3)] == [(-1, 0), (0, 1), (1, 2)]
    t: Tuple[int, ...] = (1, 2, 3)
    assert [x for x in t if (t := (9,))] == [1, 2, 3]
    n = 3
    assert [i for i in range(n) if (n := 0) == 0] == [0, 1, 2]

def gen() -> Iterator[object]:
    i = 0
    yield pair(i, (i := 1))
    yield collect(i, (yield i), (i := 2))

def test_generator() -> None:
    assert list(gen()) == [(0, 1), 1, ((1, None, 2), {})]

def maybe_unbound(flag: bool) -> object:
    if flag:
        x = 0
    return pair(x, (x := 1))

def test_unbound_local() -> None:
    assert maybe_unbound(True) == (0, 1)
    with assertRaises(UnboundLocalError):
        maybe_unbound(False)

[case testFStrings]
from datetime import datetime

def test_fstring_equal_sign() -> None:
    today = datetime(year=2017, month=1, day=27)
    assert f"{today=:%B %d, %Y}" == 'today=January 27, 2017' # using date format specifier and debugging

    foo = "bar"
    assert f"{ foo = }" == " foo = 'bar'" # preserves whitespace

    line = "The mill's closed"
    assert f"{line = }" == 'line = "The mill\'s closed"'
    assert f"{line = :20}" == "line = The mill's closed   "
    assert f"{line = !r:20}" == 'line = "The mill\'s closed" '

[case testMethodOverrideDefaultPosOnly1]
class Foo:
    def f(self, x: int=20, /, *, z: int=10) -> None:
        pass

class Bar(Foo):
    def f(self, *args: int, **kwargs: int) -> None:
        print("stuff", args, kwargs)

def test_pos_only() -> None:
    z: Foo = Bar()
    z.f(1, z=50)
    z.f()
    z.f(1)
    z.f(z=50)

[out]
stuff (1,) {'z': 50}
stuff () {}
stuff (1,) {}
stuff () {'z': 50}