Python's built-in exceptions handle many common error situations, but sometimes you need to identify and respond to specific conditions unique to your program. Custom exceptions give you the flexibility to define clear, meaningful error types that make your code easier to understand and maintain.

In this challenge, you will:
- Define your own exception class for a specific error case;
- Write a function that uses this custom exception to handle invalid input.

By practicing with custom exceptions, you gain valuable skills for building robust Python programs that communicate errors clearly and help others understand your code's intent.


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

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

    def test_function_exists(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'check_positive_number', None)
        _dynamic_test(
            self,
            callable(func),
            "Function check_positive_number is defined",
            "Function check_positive_number is not defined",
        )

    def test_positive_number_returns(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.check_positive_number(5)
        _dynamic_test(
            self,
            result == 5,
            "Function returns the positive number itself",
            f"Expected 5, got {result}",
        )

    def test_zero_returns(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.check_positive_number(0)
        _dynamic_test(
            self,
            result == 0,
            "Function returns zero correctly",
            f"Expected 0, got {result}",
        )

    def test_negative_number_raises(self):
        import user_code
        importlib.reload(user_code)
        try:
            user_code.check_positive_number(-10)
            raised = False
        except Exception as e:
            raised = isinstance(e, user_code.NegativeNumberError)
        _dynamic_test(
            self,
            raised,
            "Function raises NegativeNumberError for negative input",
            "Function did not raise NegativeNumberError for negative input",
        )

    def test_custom_exception_message(self):
        import user_code
        importlib.reload(user_code)
        try:
            user_code.check_positive_number(-42)
        except Exception as e:
            msg = str(e)
            _dynamic_test(
                self,
                "negative" in msg.lower(),
                "NegativeNumberError message contains the word 'negative'",
                f"NegativeNumberError message is not informative: '{msg}'",
            )
        else:
            _dynamic_test(
                self,
                False,
                "Exception was raised as expected",
                "Exception was not raised for negative input",
            )

    def test_example_usage_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        code = (
            "try:\\n"
            "    result = check_positive_number(-5)\\n"
            "except NegativeNumberError:\\n"
            "    print('You entered a negative number!')\\n"
        )
        ns = {}
        exec(code, user_code.__dict__, ns)
        with redirect_stdout(f):
            exec(code, user_code.__dict__, ns)
        output = normalize_text(f.getvalue())
        expected = normalize_text("You entered a negative number!")
        _dynamic_test(
            self,
            expected in output,
            "Output matches example usage for negative input",
            f"Expected output not found. Got: '{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()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    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] = []
                    
                    return '\\n'.join(lines)
    return code

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


test_main.py

A beginner-friendly course introducing Python's error handling mechanisms, including try-except blocks, exception types, and best practices for writing robust code.

Learn what exceptions are in Python, why they occur, and how to handle them using basic try-except blocks.

Explore more advanced features of Python's exception handling, including else, finally, and handling multiple exceptions.

Learn how to define your own exceptions and follow best practices for robust error handling in Python.

Challenge: Creating and Using Custom Exceptions

Ratkaisu

Challenge: Creating and Using Custom Exceptions

Ratkaisu