import unittest
import sys
import re

# Helper function to dynamically generate test names and assertions
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)


class TestUserCode(unittest.TestCase):

    def test_small_int_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "small_int"),
            "The `small_int` variable is declared.",
            "Expected `small_int` to be declared."
        )

    def test_small_int_value(self):
        import user_code
        try:
            condition = user_code.small_int == 100
            failure_message = f"Expected `small_int` to be `100`, but got `{user_code.small_int}`."
        except AttributeError:
            condition = False
            failure_message = "The `small_int` variable is not declared."
        _dynamic_test(
            self,
            condition,
            "The `small_int` variable equals `100`.",
            failure_message
        )

    def test_large_int_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "large_int"),
            "The `large_int` variable is declared.",
            "Expected `large_int` to be declared."
        )

    def test_large_int_value(self):
        import user_code
        try:
            condition = user_code.large_int == 1000
            failure_message = f"Expected `large_int` to be `1000`, but got `{user_code.large_int}`."
        except AttributeError:
            condition = False
            failure_message = "The `large_int` variable is not declared."
        _dynamic_test(
            self,
            condition,
            "The `large_int` variable equals `1000`.",
            failure_message
        )

    def test_is_cached_is_true(self):
        import user_code
        try:
            condition = user_code.is_cached is True
            failure_message = f"Expected `is_cached` to be `True` (small integer cache), but got `{user_code.is_cached}`."
        except AttributeError:
            condition = False
            failure_message = "The `is_cached` variable is not declared."
        _dynamic_test(
            self,
            condition,
            "The `is_cached` variable is `True` – the small integer cache is in effect.",
            failure_message
        )

    def test_list_size_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "list_size"),
            "The `list_size` variable is declared.",
            "Expected `list_size` to be declared."
        )

    def test_list_size_is_correct(self):
        import user_code
        transactions = [100, 200, 100, 300, 100, 200]
        expected = sys.getsizeof(transactions)
        try:
            condition = user_code.list_size == expected
            failure_message = f"Expected `list_size` to be `{expected}`, but got `{user_code.list_size}`."
        except AttributeError:
            condition = False
            failure_message = "The `list_size` variable is not declared."
        _dynamic_test(
            self,
            condition,
            f"The `list_size` equals `{expected}` bytes.",
            failure_message
        )

    def test_ref_count_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "ref_count"),
            "The `ref_count` variable is declared.",
            "Expected `ref_count` to be declared."
        )

    def test_getsizeof_used(self):
        with open("user_code.py", "r") as file:
            source = file.read()
        _dynamic_test(
            self,
            bool(re.search(r"sys\.getsizeof\s*\(", source)),
            "`sys.getsizeof()` is used to measure the list size.",
            "Expected `sys.getsizeof()` to be used."
        )

    def test_getrefcount_used(self):
        with open("user_code.py", "r") as file:
            source = file.read()
        _dynamic_test(
            self,
            bool(re.search(r"sys\.getrefcount\s*\(", source)),
            "`sys.getrefcount()` is used to measure the reference count.",
            "Expected `sys.getrefcount()` to be used."
        )


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

test_main.py

Master the skills needed to understand Python's memory management internals and performance optimization techniques. This course is designed for intermediate and advanced Python developers who want to understand how Python handles memory, write memory-efficient code, detect and fix memory leaks, and optimize performance in real-world applications.

Explore the essentials of Python's memory management, including reference counting, garbage collection, and memory allocation strategies.

Get hands-on experience with practical techniques for writing memory-efficient Python code, including specialized data structures and tools for controlling object lifecycle.

Master the skills needed to profile memory usage and detect memory leaks in Python applications.

Explore the essentials of advanced memory and performance optimization patterns, including object interning, memory inspection tools, and the GIL's impact on memory access.

Challenge: Exploring Object Memory

Oplossing