Testen mit unittest

import unittest


def apply_discount(price: float, percent: float) -> float:
    """Returns price reduced by percent, rounded to cents."""
    if not 0 <= percent <= 100:
        raise ValueError(f"percent must be 0-100, got {percent}")
    return round(price * (100 - percent) / 100, 2)


class TestDiscount(unittest.TestCase):
    def test_no_discount(self) -> None:
        self.assertEqual(apply_discount(80.0, 0), 80.0)

    # Add three more tests:
    # - 50 percent off 80.0 is 40.0
    # - a percent above 100 raises ValueError
    # - a negative percent raises ValueError


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

import unittest

import main


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


def subtracts_percent(price, percent):
    if not 0 <= percent <= 100:
        raise ValueError(percent)
    return round(price - percent, 2)


def no_upper_limit(price, percent):
    if percent < 0:
        raise ValueError(percent)
    return round(price * (100 - percent) / 100, 2)


def no_lower_limit(price, percent):
    if percent > 100:
        raise ValueError(percent)
    return round(price * (100 - percent) / 100, 2)


def test_correct_code_passes():
    """Ihre Tests bestehen mit dem korrekten apply_discount"""
    result = run_against(main.apply_discount)
    failing = [test.id() for test, _ in result.failures + result.errors]
    assert result.wasSuccessful(), f"diese Tests scheitern an korrektem Code: {failing}"
    assert result.testsRun >= 4, f"{result.testsRun} Tests liefen; schreiben Sie mindestens 4"


def test_catches_wrong_formula():
    """Ihre Tests erkennen eine Formel, die den Prozentsatz als Geldbetrag abzieht"""
    result = run_against(subtracts_percent)
    assert not result.wasSuccessful(), "alle Tests bestehen, obwohl apply_discount(80.0, 50) 30.0 liefert; prüfen Sie einen echten Rabatt"


def test_catches_missing_upper_limit():
    """Ihre Tests erkennen eine fehlende Prüfung auf Prozentsätze über 100"""
    result = run_against(no_upper_limit)
    assert not result.wasSuccessful(), "alle Tests bestehen, obwohl apply_discount(80.0, 120) einen Preis liefert; prüfen Sie, dass ValueError ausgelöst wird"


def test_catches_missing_lower_limit():
    """Ihre Tests erkennen eine fehlende Prüfung auf negative Prozentsätze"""
    result = run_against(no_lower_limit)
    assert not result.wasSuccessful(), "alle Tests bestehen, obwohl apply_discount(80.0, -5) einen Preis liefert; prüfen Sie, dass ValueError ausgelöst wird"

import unittest


def summarize(case: type[unittest.TestCase]) -> str:
    # 1. Load the tests of case with unittest.TestLoader().loadTestsFromTestCase.
    # 2. Run the suite into a unittest.TestResult.
    # 3. Return "<run> run, <failed> failed, <errors> errors: OK",
    #    with FAILED instead of OK when a test did not pass.
    return ""


class TestDemo(unittest.TestCase):
    def test_ok(self) -> None:
        self.assertEqual(1 + 1, 2)

    def test_wrong(self) -> None:
        self.assertEqual(1 + 1, 3)


if __name__ == "__main__":
    print(summarize(TestDemo))

import unittest

from main import summarize


class AllPass(unittest.TestCase):
    def test_one(self):
        self.assertEqual(len("ab"), 2)

    def test_two(self):
        self.assertTrue("abc".startswith("a"))


class Mixed(unittest.TestCase):
    def test_pass(self):
        self.assertEqual(3 * 3, 9)

    def test_fail(self):
        self.assertEqual(3 * 3, 6)

    def test_error(self):
        int("nine")


class NoTests(unittest.TestCase):
    def check_something(self):
        self.assertEqual(1, 2)


def test_all_pass():
    """Zwei bestandene Tests ergeben OK"""
    got = summarize(AllPass)
    assert got == "2 run, 0 failed, 0 errors: OK", f"summarize lieferte {got!r}"


def test_mixed():
    """Ein Fehlschlag und ein Fehler werden getrennt gezählt"""
    got = summarize(Mixed)
    assert got == "3 run, 1 failed, 1 errors: FAILED", f"summarize lieferte {got!r}"


def test_no_tests():
    """Eine Klasse ohne test_-Methoden führt nichts aus"""
    got = summarize(NoTests)
    assert got == "0 run, 0 failed, 0 errors: OK", f"summarize lieferte {got!r}"