Brugerdefinerede undtagelser giver mulighed for at definere fejlkategorier, der beskriver specifikke problemer i koden. I Python oprettes en brugerdefineret undtagelse ved at nedarve fra `Exception`. Undtagelsen udløses med `raise`, når en bestemt betingelse er opfyldt, og håndteres med et `try-except`-blok.

import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_custom_exception_exists(self):
        import user_code
        importlib.reload(user_code)
        exc = getattr(user_code, 'NegativeNumberError', None)
        _dynamic_test(
            self,
            exc is not None and issubclass(exc, Exception),
            "NegativeNumberError class is defined and inherits from Exception",
            "NegativeNumberError class not found or does not inherit from Exception."
        )

    def test_function_returns_positive(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'check_positive_number', None)
        _dynamic_test(
            self,
            callable(func),
            "check_positive_number function is defined",
            "check_positive_number function is not defined."
        )
        result = func(10)
        _dynamic_test(
            self,
            result == 10,
            "Function returns the positive number unchanged",
            f"Expected 10, got {result}"
        )

    def test_function_returns_zero(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'check_positive_number', None)
        result = func(0)
        _dynamic_test(
            self,
            result == 0,
            "Function returns zero unchanged",
            f"Expected 0, got {result}"
        )

    def test_function_raises_on_negative(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'check_positive_number', None)
        exc = getattr(user_code, 'NegativeNumberError', None)
        raised = False
        try:
            func(-5)
        except Exception as e:
            raised = isinstance(e, exc)
        _dynamic_test(
            self,
            raised,
            "Function raises NegativeNumberError for negative input",
            "Function did not raise NegativeNumberError for negative input."
        )

    def test_print_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "number must be non-negative" in output,
            "Output includes exception message for negative input",
            f"Expected exception message not found in output: {output}"
        )
        _dynamic_test(
            self,
            "3" in output,
            "Output includes result for positive input",
            f"Expected output for positive input (3) not found in output: {output}"
        )
        _dynamic_test(
            self,
            "0" in output,
            "Output includes result for zero input",
            f"Expected output for zero input (0) not found in output: {output}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True
    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Du vil opnå praktiske færdigheder i Pythons moduler og imports for effektiv kodestyring. Behersk avancerede teknikker til fejlhåndtering for mere pålidelige applikationer, automatiser filoperationer med filhåndtering, og lær robuste teststrategier med Pytest og Unittest for at sikre din kodes integritet.

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

Challenge: Fang det Negative

Løsning