concurrent.futures

from collections.abc import Callable
from concurrent.futures import ThreadPoolExecutor, as_completed


def fetch_all(names: list[str], fetch: Callable[[str], str], workers: int = 4) -> dict[str, str]:
    """Fetch every name in a thread pool. Map each name to its text, or to "error: <exception>"."""
    # One after another, and the first error stops everything.
    # Submit every fetch to a ThreadPoolExecutor and collect them with as_completed.
    return {name: fetch(name) for name in names}

import threading

from main import fetch_all

PAGES = {"home": "welcome", "about": "about us"}


def fake_fetch(name):
    return PAGES[name]


def test_all_pages():
    """Jede Seite wird geladen und unter ihrem Namen gespeichert"""
    got = fetch_all(["home", "about"], fake_fetch)
    assert got == {"home": "welcome", "about": "about us"}, f"fetch_all lieferte {got!r}"


def test_errors_are_kept():
    """Ein gescheiterter Abruf ergibt "error: <Exception>", die anderen kommen trotzdem an"""
    got = fetch_all(["home", "missing"], fake_fetch)
    assert got == {"home": "welcome", "missing": "error: 'missing'"}, f"fetch_all lieferte {got!r}"


def test_fetches_overlap():
    """Drei Abrufe laufen gleichzeitig in Pool-Threads"""
    barrier = threading.Barrier(3, timeout=0.5)

    def slow_fetch(name):
        barrier.wait()
        return threading.current_thread().name

    try:
        got = fetch_all(["a", "b", "c"], slow_fetch, workers=3)
    except threading.BrokenBarrierError:
        got = {}
    threads = sorted(got.values())
    assert len(threads) == 3 and "MainThread" not in threads, f"die Abrufe liefen in {threads!r}: reichen Sie alle beim Executor ein"

from concurrent.futures import ProcessPoolExecutor


def check_positive(n: int) -> int:
    """Return n squared, or raise ValueError for a negative n."""
    if n < 0:
        raise ValueError(f"{n} is negative")
    return n * n


def run_checks(numbers: list[int]) -> tuple[list[int], list[str]]:
    """Run check_positive in worker processes; return (sorted results, sorted error messages)."""
    results: list[int] = []
    errors: list[str] = []
    with ProcessPoolExecutor(max_workers=2) as executor:
        futures = [executor.submit(check_positive, n) for n in numbers]
        for future in futures:
            # result() raises the worker's ValueError here. Collect it in errors instead.
            results.append(future.result())
    return sorted(results), sorted(errors)


if __name__ == "__main__":
    print(run_checks([3, -1, 2]))

from main import run_checks


def test_all_good():
    """Positive Zahlen ergeben ihre sortierten Quadrate und keine Fehler"""
    got = run_checks([3, 1, 2])
    assert got == ([1, 4, 9], []), f"run_checks([3, 1, 2]) lieferte {got!r}"


def test_errors_collected():
    """Negative Zahlen landen als Fehlermeldungen; die anderen zählen trotzdem"""
    got = run_checks([3, -1, 2, -5])
    assert got == ([4, 9], ["-1 is negative", "-5 is negative"]), f"run_checks([3, -1, 2, -5]) lieferte {got!r}"


def test_only_errors():
    """Nur negative Zahlen ergeben keine Ergebnisse und je eine Meldung"""
    got = run_checks([-2])
    assert got == ([], ["-2 is negative"]), f"run_checks([-2]) lieferte {got!r}"