doctest and what to test

def median(values: list[float]) -> float:
    """Return the middle value; for an even count, the mean of the two middle values.

    >>> median([3, 1, 2])
    2
    """
    # Add two more examples to the docstring above:
    # - an even number of values, such as [4, 1, 3, 2]
    # - an empty list, which raises ValueError: median of an empty list
    if not values:
        raise ValueError("median of an empty list")
    ordered = sorted(values)
    middle = len(ordered) // 2
    if len(ordered) % 2 == 1:
        return ordered[middle]
    return (ordered[middle - 1] + ordered[middle]) / 2


if __name__ == "__main__":
    print(median([3, 1, 2]), median([4, 1, 3, 2]))

import doctest

import main


def run_examples(implementation):
    parser = doctest.DocTestParser()
    test = parser.get_doctest(main.median.__doc__ or "", {"median": implementation}, "median", "main.py", 0)
    runner = doctest.DocTestRunner()
    return runner.run(test, out=lambda text: None)


def middle_only(values):
    ordered = sorted(values)
    return ordered[len(ordered) // 2]


def no_empty_check(values):
    ordered = sorted(values)
    middle = len(ordered) // 2
    if len(ordered) % 2 == 1:
        return ordered[middle]
    return (ordered[middle - 1] + ordered[middle]) / 2


def test_examples_pass():
    """Your docstring has at least 3 examples, and they pass"""
    failed, attempted = run_examples(main.median)
    assert attempted >= 3, f"the docstring has {attempted} examples; write at least 3"
    assert failed == 0, f"{failed} of your examples fail on the correct median"


def test_catches_even_bug():
    """Your examples catch a median that ignores even counts"""
    failed, _ = run_examples(middle_only)
    assert failed > 0, "every example passes when median([4, 1, 3, 2]) returns 3; add an even-length example"


def test_catches_empty_bug():
    """Your examples catch a median without the empty-list check"""
    failed, _ = run_examples(no_empty_check)
    assert failed > 0, "every example passes when median([]) raises IndexError; show the ValueError in an example"

import unittest


def is_valid_username(name: str) -> bool:
    """3 to 15 characters: letters, digits or _, starting with a letter."""
    if not 3 <= len(name) <= 15:
        return False
    if not name[0].isalpha():
        return False
    return all(ch.isalnum() or ch == "_" for ch in name)


class TestUsername(unittest.TestCase):
    # Split this into focused tests, one behaviour each, and add the
    # missing edge cases: both length limits and their neighbours,
    # a name starting with a digit, and a character that is not allowed.
    def test_everything(self) -> None:
        self.assertTrue(is_valid_username("ada_1815"))
        self.assertFalse(is_valid_username("al"))


if __name__ == "__main__":
    suite = unittest.TestLoader().loadTestsFromTestCase(TestUsername)
    unittest.TextTestRunner(verbosity=2).run(suite)

import unittest

import main


def run_against(implementation):
    saved = main.is_valid_username
    main.is_valid_username = implementation
    try:
        result = unittest.TestResult()
        unittest.TestLoader().loadTestsFromTestCase(main.TestUsername).run(result)
    finally:
        main.is_valid_username = saved
    return result


def rules(name, low=3, high=15, digit_start=False, hyphen=False):
    if not low <= len(name) <= high:
        return False
    if not (name[0].isalpha() or (digit_start and name[0].isdigit())):
        return False
    return all(ch.isalnum() or ch == "_" or (hyphen and ch == "-") for ch in name)


BROKEN = {
    "3 characters are refused": lambda name: rules(name, low=4),
    "2 characters are accepted": lambda name: rules(name, low=2),
    "15 characters are refused": lambda name: rules(name, high=14),
    "16 characters are accepted": lambda name: rules(name, high=16),
    "a name may start with a digit": lambda name: rules(name, digit_start=True),
    "a hyphen is accepted": lambda name: rules(name, hyphen=True),
}


def test_correct_code_passes():
    """At least 5 tests, and all pass on the correct function"""
    result = run_against(main.is_valid_username)
    failing = [test.id() for test, _ in result.failures + result.errors]
    assert result.wasSuccessful(), f"these tests fail on correct code: {failing}"
    assert result.testsRun >= 5, f"{result.testsRun} tests ran; write at least 5 focused tests"


def test_every_bug_is_caught():
    """Each of six one-rule bugs makes a test fail"""
    missed = [bug for bug, broken in BROKEN.items() if run_against(broken).wasSuccessful()]
    if missed:
        assert False, f"no test fails when {missed[0]}; add that edge case"


def test_tests_are_focused():
    """A one-rule bug leaves the other tests passing"""
    for bug, broken in BROKEN.items():
        result = run_against(broken)
        bad = len(result.failures) + len(result.errors)
        assert bad < result.testsRun, f"when {bug}, every test fails; test one behaviour per test"