Custom exceptions let you define error types that describe specific problems in your code. In Python, create a custom exception by subclassing `Exception`. Raise your exception with `raise` when a certain condition is met, and handle it using a `try-except` block.

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

A deep dive into advanced structural programming concepts in Python, focusing on robust file handling, error management, concurrency, asynchronous programming and testing.

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: Catching the Negative

Solution