doctest und was man testet

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():
    """Ihr Docstring hat mindestens 3 Beispiele, und sie bestehen"""
    failed, attempted = run_examples(main.median)
    assert attempted >= 3, f"der Docstring hat {attempted} Beispiele; schreiben Sie mindestens 3"
    assert failed == 0, f"{failed} Ihrer Beispiele scheitern am korrekten median"


def test_catches_even_bug():
    """Ihre Beispiele erkennen ein median, das gerade Anzahlen übergeht"""
    failed, _ = run_examples(middle_only)
    assert failed > 0, "alle Beispiele bestehen, obwohl median([4, 1, 3, 2]) 3 liefert; ergänzen Sie ein Beispiel mit gerader Länge"


def test_catches_empty_bug():
    """Ihre Beispiele erkennen ein median ohne Prüfung auf die leere Liste"""
    failed, _ = run_examples(no_empty_check)
    assert failed > 0, "alle Beispiele bestehen, obwohl median([]) IndexError auslöst; zeigen Sie den ValueError in einem Beispiel"

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 Zeichen abgelehnt werden": lambda name: rules(name, low=4),
    "2 Zeichen angenommen werden": lambda name: rules(name, low=2),
    "15 Zeichen abgelehnt werden": lambda name: rules(name, high=14),
    "16 Zeichen angenommen werden": lambda name: rules(name, high=16),
    "ein Name mit einer Ziffer beginnen darf": lambda name: rules(name, digit_start=True),
    "ein Bindestrich angenommen wird": lambda name: rules(name, hyphen=True),
}


def test_correct_code_passes():
    """Mindestens 5 Tests, und alle bestehen mit der korrekten Funktion"""
    result = run_against(main.is_valid_username)
    failing = [test.id() for test, _ in result.failures + result.errors]
    assert result.wasSuccessful(), f"diese Tests scheitern an korrektem Code: {failing}"
    assert result.testsRun >= 5, f"{result.testsRun} Tests liefen; schreiben Sie mindestens 5 fokussierte Tests"


def test_every_bug_is_caught():
    """Jeder von sechs Ein-Regel-Fehlern lässt einen Test scheitern"""
    missed = [bug for bug, broken in BROKEN.items() if run_against(broken).wasSuccessful()]
    if missed:
        assert False, f"kein Test scheitert, wenn {missed[0]}; ergänzen Sie diesen Randfall"


def test_tests_are_focused():
    """Ein Ein-Regel-Fehler lässt die übrigen Tests bestehen"""
    for bug, broken in BROKEN.items():
        result = run_against(broken)
        bad = len(result.failures) + len(result.errors)
        assert bad < result.testsRun, f"wenn {bug}, scheitert jeder Test; prüfen Sie ein Verhalten pro Test"