Generics with the PEP 695 syntax

from collections.abc import Sized


def first_or(items: list[object], default: object) -> object:
    return items[0] if items else default


def longest(items: list[Sized]) -> Sized | None:
    if not items:
        return None
    return max(items, key=len)

from collections.abc import Sized
from typing import get_type_hints

from main import first_or, longest


def test_first_or_is_generic():
    """first_or has one type parameter, T, used in all its hints"""
    params = first_or.__type_params__
    assert len(params) == 1, f"first_or.__type_params__ is {params!r}, expected one parameter"
    t = params[0]
    got = get_type_hints(first_or)
    assert got == {"items": list[t], "default": t, "return": t}, f"the hints of first_or are {got!r}"


def test_first_or_behaviour():
    """first_or gives the first item, or the default for an empty list"""
    got = first_or([3, 4], 0), first_or([], "none")
    assert got == (3, "none"), f"first_or returned {got!r}, expected (3, 'none')"


def test_longest_bound():
    """longest has one type parameter, bound to Sized"""
    params = longest.__type_params__
    assert len(params) == 1 and params[0].__bound__ is Sized, f"longest.__type_params__ is {params!r}; expected one parameter bound to Sized"
    s = params[0]
    got = get_type_hints(longest)
    assert got == {"items": list[s], "return": s | None}, f"the hints of longest are {got!r}"


def test_longest_behaviour():
    """longest returns the first longest item, or None for an empty list"""
    got = longest(["tea", "coffee", "cocoa!"]), longest([{1}, {2, 3}]), longest([])
    assert got == ("coffee", {2, 3}, None), f"longest returned {got!r}"

# Add the alias here: Batch[T] stands for list[T].


class Queue:
    """First in, first out."""

    def __init__(self) -> None:
        self._items: list[object] = []

    def put(self, item: object) -> None:
        self._items.append(item)

    def get(self) -> object:
        return self._items.pop(0)

    def take(self, n: int) -> list[object]:
        # Remove up to n items from the front and return them.
        return []

    def __len__(self) -> int:
        return len(self._items)

from typing import TypeAliasType

import main
from main import Queue


def test_batch_alias():
    """Batch is a generic type alias for list[T]"""
    batch = getattr(main, "Batch", None)
    assert isinstance(batch, TypeAliasType), f"main.Batch is {batch!r}, expected an alias from a type statement"
    assert len(batch.__type_params__) == 1, f"Batch has the type parameters {batch.__type_params__!r}, expected one"
    t = batch.__type_params__[0]
    assert batch.__value__ == list[t], f"Batch stands for {batch.__value__!r}, expected list[T]"


def test_queue_is_generic():
    """Queue has one type parameter, and take() returns Batch[T]"""
    params = Queue.__type_params__
    assert len(params) == 1, f"Queue.__type_params__ is {params!r}, expected one parameter"
    got = Queue.take.__annotations__["return"]
    assert got == main.Batch[params[0]], f"take() is annotated to return {got!r}, expected Batch[T]"


def test_first_in_first_out():
    """get() returns the items in the order they were put"""
    queue = Queue[str]()
    for word in ["a", "b", "c"]:
        queue.put(word)
    got = queue.get(), queue.get(), len(queue)
    assert got == ("a", "b", 1), f"two get() calls and len() gave {got!r}, expected ('a', 'b', 1)"


def test_take():
    """take(2) removes the two oldest items, and take(5) the one left"""
    queue = Queue[int]()
    for n in [1, 2, 3]:
        queue.put(n)
    got = queue.take(2), queue.take(5), len(queue)
    assert got == ([1, 2], [3], 0), f"take(2), take(5) and len() gave {got!r}, expected ([1, 2], [3], 0)"