Generics mit der Syntax aus PEP 695

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 hat einen Typparameter T, der in allen Hinweisen steht"""
    params = first_or.__type_params__
    assert len(params) == 1, f"first_or.__type_params__ ist {params!r}, erwartet war ein Parameter"
    t = params[0]
    got = get_type_hints(first_or)
    assert got == {"items": list[t], "default": t, "return": t}, f"die Hinweise von first_or sind {got!r}"


def test_first_or_behaviour():
    """first_or liefert das erste Element oder bei leerer Liste den Standardwert"""
    got = first_or([3, 4], 0), first_or([], "none")
    assert got == (3, "none"), f"first_or lieferte {got!r}, erwartet war (3, 'none')"


def test_longest_bound():
    """longest hat einen Typparameter, an Sized gebunden"""
    params = longest.__type_params__
    assert len(params) == 1 and params[0].__bound__ is Sized, f"longest.__type_params__ ist {params!r}; erwartet war ein an Sized gebundener Parameter"
    s = params[0]
    got = get_type_hints(longest)
    assert got == {"items": list[s], "return": s | None}, f"die Hinweise von longest sind {got!r}"


def test_longest_behaviour():
    """longest liefert das erste längste Element oder None bei leerer Liste"""
    got = longest(["tea", "coffee", "cocoa!"]), longest([{1}, {2, 3}]), longest([])
    assert got == ("coffee", {2, 3}, None), f"longest lieferte {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 ist ein generischer Typ-Alias für list[T]"""
    batch = getattr(main, "Batch", None)
    assert isinstance(batch, TypeAliasType), f"main.Batch ist {batch!r}, erwartet war ein Alias aus einer type-Anweisung"
    assert len(batch.__type_params__) == 1, f"Batch hat die Typparameter {batch.__type_params__!r}, erwartet war einer"
    t = batch.__type_params__[0]
    assert batch.__value__ == list[t], f"Batch steht für {batch.__value__!r}, erwartet war list[T]"


def test_queue_is_generic():
    """Queue hat einen Typparameter, und take() liefert Batch[T]"""
    params = Queue.__type_params__
    assert len(params) == 1, f"Queue.__type_params__ ist {params!r}, erwartet war ein Parameter"
    got = Queue.take.__annotations__["return"]
    assert got == main.Batch[params[0]], f"take() ist mit Rückgabe {got!r} annotiert, erwartet war Batch[T]"


def test_first_in_first_out():
    """get() liefert die Elemente in der Reihenfolge, in der sie hineinkamen"""
    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"zwei get()-Aufrufe und len() ergaben {got!r}, erwartet war ('a', 'b', 1)"


def test_take():
    """take(2) entfernt die zwei ältesten Elemente, take(5) das übrige"""
    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) und len() ergaben {got!r}, erwartet war ([1, 2], [3], 0)"