Messen mit timeit

import timeit
from collections.abc import Callable


def best_per_call(func: Callable[[], object], number: int = 1000, repeat: int = 5) -> float:
    # One timing is not enough: take `repeat` timings of `number` calls each,
    # and return the fastest one divided by `number`.
    return timeit.timeit(func, number=number)

import math
import timeit
from unittest import mock

from main import best_per_call


def test_calls():
    """number=10 und repeat=3 rufen die Funktion 30-mal auf"""
    calls = []
    best_per_call(lambda: calls.append(1), number=10, repeat=3)
    assert len(calls) == 30, f"die Funktion wurde {len(calls)}-mal aufgerufen, erwartet 30 (10 Aufrufe in jeder von 3 Messungen)"


def test_minimum_per_call():
    """Messungen von 0,5, 0,2 und 0,4 s für 100 Aufrufe ergeben 0,002 s pro Aufruf"""
    with mock.patch("timeit.repeat", return_value=[0.5, 0.2, 0.4]) as fake:
        got = best_per_call(lambda: None, number=100, repeat=3)
    assert fake.called, "best_per_call hat timeit.repeat nicht aufgerufen"
    assert math.isclose(got, 0.002), f"Ergebnis {got!r}, erwartet 0.002: das Minimum 0.2 geteilt durch number=100"


def test_defaults():
    """Ohne Argumente: 5 Messungen mit je 1000 Aufrufen"""
    calls = []
    best_per_call(lambda: calls.append(1))
    assert len(calls) == 5000, f"die Funktion wurde {len(calls)}-mal aufgerufen, erwartet 5000"


def test_returns_float():
    """Ein echter Lauf liefert einen positiven float"""
    got = best_per_call(lambda: sum(range(10)), number=50)
    assert isinstance(got, float) and got > 0, f"Ergebnis {got!r}, erwartet ein positiver float"

import timeit
from collections.abc import Callable


def compare(slow: Callable[[int], object], fast: Callable[[int], object], arg: int, number: int = 200) -> float:
    # 1. Raise ValueError if slow(arg) and fast(arg) differ.
    # 2. Time both with timeit.repeat and return min(slow) / min(fast).
    slow_time = timeit.timeit(lambda: slow(arg), number=number)
    fast_time = timeit.timeit(lambda: fast(arg), number=number)
    return fast_time / slow_time

import math
from unittest import mock

from main import compare

who = []


def slow(n):
    who.append("slow")
    return n * 2


def fast(n):
    who.append("fast")
    return n + n


def wrong(n):
    who.append("wrong")
    return n


def fake_repeat(stmt, number=1000000, repeat=5, **kwargs):
    """Ruft stmt einmal auf und liefert erfundene Messwerte für die Version, die lief."""
    stmt()
    return [0.9, 0.6, 0.8] if who[-1] == "slow" else [0.3, 0.2, 0.25]


def test_ratio():
    """Bestzeiten von 0,6 s und 0,2 s ergeben das Verhältnis 3,0"""
    with mock.patch("timeit.repeat", side_effect=fake_repeat):
        got = compare(slow, fast, 21)
    assert math.isclose(got, 3.0), f"Ergebnis {got!r}, erwartet 3.0: Minimum der langsamen / Minimum der schnellen Messungen"


def test_different_results():
    """Versionen mit verschiedenen Ergebnissen lösen ValueError aus"""
    try:
        compare(slow, wrong, 21)
    except ValueError:
        return
    raise AssertionError("compare(slow, wrong, 21) hat keinen ValueError ausgelöst, obwohl 42 != 21")


def test_checks_before_timing():
    """Verschiedene Ergebnisse fallen auf, bevor irgendetwas gemessen wird"""
    with mock.patch("timeit.repeat", side_effect=fake_repeat) as fake:
        try:
            compare(slow, wrong, 21)
        except ValueError:
            pass
    assert fake.call_count == 0, f"timeit.repeat wurde vor der Prüfung {fake.call_count}-mal aufgerufen: vergleichen Sie zuerst die Ergebnisse"


def test_real_run():
    """Ein echter Lauf liefert einen positiven float"""
    got = compare(slow, fast, 5, number=20)
    assert isinstance(got, float) and got > 0, f"Ergebnis {got!r}, erwartet ein positiver float"