Measuring with 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 and repeat=3 call the function 30 times"""
    calls = []
    best_per_call(lambda: calls.append(1), number=10, repeat=3)
    assert len(calls) == 30, f"the function was called {len(calls)} times, expected 30 (10 calls in each of 3 timings)"


def test_minimum_per_call():
    """Timings of 0.5, 0.2 and 0.4 s for 100 calls give 0.002 s per call"""
    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 did not call timeit.repeat"
    assert math.isclose(got, 0.002), f"got {got!r}, expected 0.002: the minimum, 0.2, divided by number=100"


def test_defaults():
    """Without arguments: 5 timings of 1000 calls"""
    calls = []
    best_per_call(lambda: calls.append(1))
    assert len(calls) == 5000, f"the function was called {len(calls)} times, expected 5000"


def test_returns_float():
    """A real run returns a positive float"""
    got = best_per_call(lambda: sum(range(10)), number=50)
    assert isinstance(got, float) and got > 0, f"got {got!r}, expected a positive 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):
    """Calls stmt once, then returns made-up timings for whichever version ran."""
    stmt()
    return [0.9, 0.6, 0.8] if who[-1] == "slow" else [0.3, 0.2, 0.25]


def test_ratio():
    """Best times of 0.6 s and 0.2 s give a ratio of 3.0"""
    with mock.patch("timeit.repeat", side_effect=fake_repeat):
        got = compare(slow, fast, 21)
    assert math.isclose(got, 3.0), f"got {got!r}, expected 3.0: min of the slow timings / min of the fast timings"


def test_different_results():
    """Versions with different results raise ValueError"""
    try:
        compare(slow, wrong, 21)
    except ValueError:
        return
    raise AssertionError("compare(slow, wrong, 21) did not raise ValueError, although 42 != 21")


def test_checks_before_timing():
    """Different results are caught before anything is timed"""
    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 was called {fake.call_count} times before the check: compare the results first"


def test_real_run():
    """A real run returns a positive float"""
    got = compare(slow, fast, 5, number=20)
    assert isinstance(got, float) and got > 0, f"got {got!r}, expected a positive float"