Les exceptions personnalisées permettent de définir des types d’erreurs qui décrivent des problèmes spécifiques dans votre code. En Python, créez une exception personnalisée en sous-classant `Exception`. Déclenchez votre exception avec `raise` lorsqu’une condition particulière est remplie, et gérez-la à l’aide d’un bloc `try-except`.

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

Vous acquerrez des compétences pratiques dans les modules et les imports de Python pour une gestion efficace du code. Maîtrisez des techniques avancées de gestion des erreurs pour des applications plus fiables, automatisez les opérations de fichiers avec la gestion des fichiers, et apprenez des stratégies de test robustes avec Pytest et Unittest pour assurer l'intégrité de votre code.

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: Intercepter la Valeur Négative

Solution