orionis 0.438.0__py3-none-any.whl → 0.439.0__py3-none-any.whl

tests/services/introspection/reflection/test_reflection_instance.py

@@ -7,9 +7,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetInstance(self):
         """
-        Tests that the ReflectionInstance.getInstance() method returns an instance of the expected class.
-        This test creates a ReflectionInstance with a FakeClass object, retrieves the instance using getInstance(),
-        and asserts that the returned object is an instance of FakeClass.
+        Test ReflectionInstance.getInstance() method functionality.
+
+        Verifies that the getInstance() method returns the wrapped instance object 
+        correctly. Creates a ReflectionInstance wrapper around a FakeClass object
+        and validates that the retrieved instance maintains its original type.
+
+        Assertions
+        ----------
+        - Retrieved instance is of type FakeClass
         """
         reflect = ReflectionInstance(FakeClass())
         instance = reflect.getInstance()
@@ -17,10 +23,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetClass(self):
         """
-        Tests that the `getClass` method of `ReflectionInstance` returns the correct class type
-        for the given instance.
-        This test creates a `ReflectionInstance` with an instance of `FakeClass`, calls `getClass`,
-        and asserts that the returned class is `FakeClass`.
+        Test ReflectionInstance.getClass() method functionality.
+
+        Verifies that the getClass method correctly returns the class type
+        of the wrapped instance object. Creates a ReflectionInstance with 
+        a FakeClass instance and validates the returned class type.
+
+        Assertions
+        ----------
+        - Returned class equals FakeClass type
         """
         reflect = ReflectionInstance(FakeClass())
         cls = reflect.getClass()
@@ -28,9 +39,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetClassName(self):
         """
-        Tests that the ReflectionInstance correctly retrieves the class name of the given object.
-        This test creates an instance of FakeClass, wraps it with ReflectionInstance,
-        and asserts that getClassName() returns the expected class name 'FakeClass'.
+        Test ReflectionInstance.getClassName() method functionality.
+
+        Verifies that the getClassName method correctly retrieves the string
+        name of the wrapped instance's class. Creates a ReflectionInstance
+        with a FakeClass object and validates the returned class name.
+
+        Assertions
+        ----------
+        - Returned class name equals 'FakeClass'
         """
         reflect = ReflectionInstance(FakeClass())
         class_name = reflect.getClassName()
@@ -38,12 +55,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetModuleName(self):
         """
-        Tests that the `getModuleName` method of `ReflectionInstance` returns the correct module name
-        for the provided `FakeClass` instance.
+        Test ReflectionInstance.getModuleName() method functionality.
 
-        Asserts:
-            The returned module name matches the expected string
-            'tests.services.introspection.reflection.mock.fake_reflect_instance'.
+        Verifies that the getModuleName method correctly returns the fully
+        qualified module name of the wrapped instance's class. Creates a
+        ReflectionInstance with a FakeClass object and validates the module path.
+
+        Assertions
+        ----------
+        - Returned module name equals 'tests.services.introspection.reflection.mock.fake_reflect_instance'
         """
         reflect = ReflectionInstance(FakeClass())
         module_name = reflect.getModuleName()
@@ -51,11 +71,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetModuleWithClassName(self):
         """
-        Tests that the getModuleWithClassName method of ReflectionInstance returns the fully qualified
-        module and class name of the provided instance.
+        Test ReflectionInstance.getModuleWithClassName() method functionality.
+
+        Verifies that the getModuleWithClassName method returns the fully qualified
+        module path combined with the class name. Creates a ReflectionInstance
+        with a FakeClass object and validates the complete module.class path.
 
-        Asserts:
-            The returned string matches the expected module and class path for FakeClass.
+        Assertions
+        ----------
+        - Returned string equals 'tests.services.introspection.reflection.mock.fake_reflect_instance.FakeClass'
         """
         reflect = ReflectionInstance(FakeClass())
         module_with_class_name = reflect.getModuleWithClassName()
@@ -63,8 +87,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetDocstring(self):
         """
-        Test that the getDocstring method of ReflectionInstance returns the correct docstring
-        for the provided class instance.
+        Test ReflectionInstance.getDocstring() method functionality.
+
+        Verifies that the getDocstring method correctly retrieves the docstring
+        of the wrapped instance's class. Creates a ReflectionInstance with a
+        FakeClass object and compares the returned docstring with the class's __doc__.
+
+        Assertions
+        ----------
+        - Returned docstring equals FakeClass.__doc__
         """
         reflect = ReflectionInstance(FakeClass())
         docstring = reflect.getDocstring()
@@ -72,11 +103,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetBaseClasses(self):
         """
-        Tests that the getBaseClasses method of ReflectionInstance correctly retrieves
-        the base classes of the provided instance.
+        Test ReflectionInstance.getBaseClasses() method functionality.
+
+        Verifies that the getBaseClasses method correctly retrieves the base
+        classes of the wrapped instance's class. Creates a ReflectionInstance
+        with a FakeClass object and validates that the base class is included.
 
-        This test creates a ReflectionInstance for a FakeClass object, calls getBaseClasses,
-        and asserts that FakeClass's immediate base class is included in the returned list.
+        Assertions
+        ----------
+        - FakeClass.__base__ is present in the returned base classes list
         """
         reflect = ReflectionInstance(FakeClass())
         base_classes = reflect.getBaseClasses()
@@ -84,9 +119,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetSourceCode(self):
         """
-        Tests that the `getSourceCode` method of `ReflectionInstance` correctly retrieves
-        the source code of the provided class instance. Asserts that the returned source
-        code starts with the expected class definition.
+        Test ReflectionInstance.getSourceCode() method functionality.
+
+        Verifies that the getSourceCode method correctly retrieves the source
+        code of the wrapped instance's class. Creates a ReflectionInstance
+        with a FakeClass object and validates the source code content.
+
+        Assertions
+        ----------
+        - Returned source code starts with 'class FakeClass'
         """
         reflect = ReflectionInstance(FakeClass())
         source_code = reflect.getSourceCode()
@@ -94,8 +135,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetFile(self):
         """
-        Tests that the `getFile` method of `ReflectionInstance` returns the correct file path
-        for the given instance. Asserts that the returned file path ends with 'fake_reflect_instance.py'.
+        Test ReflectionInstance.getFile() method functionality.
+
+        Verifies that the getFile method correctly returns the file path
+        of the wrapped instance's class definition. Creates a ReflectionInstance
+        with a FakeClass object and validates the returned file path.
+
+        Assertions
+        ----------
+        - Returned file path ends with 'fake_reflect_instance.py'
         """
         reflect = ReflectionInstance(FakeClass())
         file_path = reflect.getFile()
@@ -103,9 +151,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetAnnotations(self):
         """
-        Test that the ReflectionInstance.getAnnotations() method returns the correct annotations
-        for the given FakeClass instance, specifically verifying that 'public_attr' is present
-        in the returned annotations.
+        Test ReflectionInstance.getAnnotations() method functionality.
+
+        Verifies that the getAnnotations method correctly returns the type
+        annotations of the wrapped instance's class. Creates a ReflectionInstance
+        with a FakeClass object and validates the presence of expected annotations.
+
+        Assertions
+        ----------
+        - 'public_attr' annotation is present in the returned annotations
         """
         reflect = ReflectionInstance(FakeClass())
         annotations = reflect.getAnnotations()
@@ -113,10 +167,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testHasAttribute(self):
         """
-        Tests the hasAttribute method of the ReflectionInstance class.
+        Test ReflectionInstance.hasAttribute() method functionality.
+
+        Verifies that the hasAttribute method correctly identifies the presence
+        or absence of attributes on the wrapped instance. Tests both existing
+        and non-existing attributes to validate proper boolean responses.
 
-        Verifies that hasAttribute returns True for an existing attribute ('public_attr')
-        and False for a non-existent attribute ('non_existent_attr') on a FakeClass instance.
+        Assertions
+        ----------
+        - Returns True for existing attribute 'public_attr'
+        - Returns False for non-existent attribute 'non_existent_attr'
         """
         reflect = ReflectionInstance(FakeClass())
         self.assertTrue(reflect.hasAttribute('public_attr'))
@@ -124,11 +184,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetAttribute(self):
         """
-        Tests the `getAttribute` method of the `ReflectionInstance` class.
+        Test ReflectionInstance.getAttribute() method functionality.
+
+        Verifies that the getAttribute method correctly retrieves attribute
+        values from the wrapped instance. Tests both existing attributes
+        and non-existent attributes to validate proper value retrieval.
 
-        Verifies that:
-        - Retrieving an existing attribute ('public_attr') returns its correct value (42).
-        - Retrieving a non-existent attribute ('non_existent_attr') returns None.
+        Assertions
+        ----------
+        - Returns correct value (42) for existing attribute 'public_attr'
+        - Returns None for non-existent attribute 'non_existent_attr'
         """
         reflect = ReflectionInstance(FakeClass())
         self.assertEqual(reflect.getAttribute('public_attr'), 42)
@@ -136,19 +201,20 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testSetAttribute(self):
         """
-        Test the setAttribute method of the ReflectionInstance class.
+        Test ReflectionInstance.setAttribute() method functionality.
 
-        This test verifies that setAttribute correctly sets the value of attributes
-        on the wrapped object, including public, protected, and private attributes.
-        It also checks that the updated values can be retrieved using getAttribute.
+        Verifies that the setAttribute method correctly sets attribute values
+        on the wrapped instance, including public, protected, and private attributes.
+        Also validates that the updated values can be retrieved using getAttribute.
 
-        Assertions:
-            - setAttribute returns True when setting a public attribute.
-            - The value of the public attribute is updated correctly.
-            - setAttribute returns True when setting a protected attribute.
-            - The value of the protected attribute is updated correctly.
-            - setAttribute returns True when setting a private attribute.
-            - The value of the private attribute is updated correctly.
+        Assertions
+        ----------
+        - setAttribute returns True when setting public attribute 'name'
+        - Public attribute value is updated correctly to 'Orionis Framework'
+        - setAttribute returns True when setting protected attribute '_version'
+        - Protected attribute value is updated correctly to '1.x'
+        - setAttribute returns True when setting private attribute '__python'
+        - Private attribute value is updated correctly to '3.13+'
         """
         reflect = ReflectionInstance(FakeClass())
         self.assertTrue(reflect.setAttribute('name', 'Orionis Framework'))
@@ -160,8 +226,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testRemoveAttribute(self):
         """
-        Test that the removeAttribute method successfully removes an attribute from the reflected instance.
-        Verifies that the attribute is removed and no longer present after removal.
+        Test ReflectionInstance.removeAttribute() method functionality.
+
+        Verifies that the removeAttribute method successfully removes an attribute
+        from the wrapped instance. Tests the removal process by first setting
+        an attribute, then removing it, and validating its absence.
+
+        Assertions
+        ----------
+        - removeAttribute returns True when removing an existing attribute
+        - Attribute is no longer present after removal (hasAttribute returns False)
         """
         reflect = ReflectionInstance(FakeClass())
         reflect.setAttribute('new_attr', 100)
@@ -170,9 +244,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetAttributes(self):
         """
-        Tests that the ReflectionInstance.getAttributes() method correctly retrieves
-        all attribute names from an instance of FakeClass, including public, protected,
-        and private attributes.
+        Test ReflectionInstance.getAttributes() method functionality.
+
+        Verifies that the getAttributes method correctly retrieves all attribute
+        names from the wrapped instance, including public, protected, and private
+        attributes. Tests comprehensive attribute visibility.
+
+        Assertions
+        ----------
+        - 'public_attr' is present in the returned attributes list
+        - '_protected_attr' is present in the returned attributes list
+        - '__private_attr' is present in the returned attributes list
         """
         reflect = ReflectionInstance(FakeClass())
         attributes = reflect.getAttributes()
@@ -182,12 +264,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicAttributes(self):
         """
-        Test that ReflectionInstance.getPublicAttributes() returns only public attributes of a class instance.
+        Test ReflectionInstance.getPublicAttributes() method functionality.
+
+        Verifies that the getPublicAttributes method returns only public attributes
+        of the wrapped instance, excluding protected and private attributes. Tests
+        proper visibility filtering based on Python naming conventions.
 
-        This test verifies that:
-        - Public attributes (e.g., 'public_attr') are included in the returned list.
-        - Protected attributes (e.g., '_protected_attr') are not included.
-        - Private attributes (e.g., '__private_attr') are not included.
+        Assertions
+        ----------
+        - 'public_attr' is included in the returned list
+        - '_protected_attr' is not included in the returned list
+        - '__private_attr' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_attributes = reflect.getPublicAttributes()
@@ -197,12 +284,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedAttributes(self):
         """
-        Test that ReflectionInstance.getProtectedAttributes() correctly identifies protected attributes.
+        Test ReflectionInstance.getProtectedAttributes() method functionality.
 
-        This test verifies that:
-        - Protected attributes (those prefixed with a single underscore) are included in the result.
-        - Public attributes are not included.
-        - Private attributes (those prefixed with double underscores) are not included.
+        Verifies that the getProtectedAttributes method correctly identifies and
+        returns only protected attributes (prefixed with single underscore) of
+        the wrapped instance, excluding public and private attributes.
+
+        Assertions
+        ----------
+        - '_protected_attr' is included in the returned list
+        - 'public_attr' is not included in the returned list
+        - '__private_attr' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_attributes = reflect.getProtectedAttributes()
@@ -212,12 +304,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateAttributes(self):
         """
-        Test that the `getPrivateAttributes` method of `ReflectionInstance` correctly identifies and returns only the private attributes of a class instance.
+        Test ReflectionInstance.getPrivateAttributes() method functionality.
+
+        Verifies that the getPrivateAttributes method correctly identifies and
+        returns only private attributes (prefixed with double underscores) of
+        the wrapped instance, excluding public and protected attributes.
 
-        This test verifies that:
-        - The private attribute (`__private_attr`) is included in the returned list.
-        - The public attribute (`public_attr`) is not included.
-        - The protected attribute (`_protected_attr`) is not included.
+        Assertions
+        ----------
+        - '__private_attr' is included in the returned list
+        - 'public_attr' is not included in the returned list
+        - '_protected_attr' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_attributes = reflect.getPrivateAttributes()
@@ -227,10 +324,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetDunderAttributes(self):
         """
-        Tests that the getDunderAttributes method of ReflectionInstance correctly retrieves
-        all double underscore (dunder) attributes from an instance of FakeClass.
+        Test ReflectionInstance.getDunderAttributes() method functionality.
+
+        Verifies that the getDunderAttributes method correctly retrieves all
+        double underscore (dunder) attributes from the wrapped instance. Tests
+        the identification of special attributes with the dunder naming pattern.
 
-        Asserts that the attribute '__dd__' is present in the returned list of dunder attributes.
+        Assertions
+        ----------
+        - '__dd__' is present in the returned list of dunder attributes
         """
         reflect = ReflectionInstance(FakeClass())
         dunder_attributes = reflect.getDunderAttributes()
@@ -238,8 +340,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetMagicAttributes(self):
         """
-        Tests that the `getMagicAttributes` method of `ReflectionInstance` returns a list of magic attributes
-        for the given instance, and verifies that the attribute '__dd__' is present in the result.
+        Test ReflectionInstance.getMagicAttributes() method functionality.
+
+        Verifies that the getMagicAttributes method returns a list of magic attributes
+        (special methods and attributes with double underscores) for the wrapped instance.
+        Tests the identification of Python magic/special attributes.
+
+        Assertions
+        ----------
+        - '__dd__' is present in the returned list of magic attributes
         """
         reflect = ReflectionInstance(FakeClass())
         magic_attributes = reflect.getMagicAttributes()
@@ -247,11 +356,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testHasMethod(self):
         """
-        Tests the hasMethod function of the ReflectionInstance class.
+        Test ReflectionInstance.hasMethod() method functionality.
+
+        Verifies that the hasMethod method correctly identifies the presence
+        or absence of methods on the wrapped instance. Tests both existing
+        and non-existing methods to validate proper boolean responses.
 
-        Verifies that hasMethod correctly identifies the presence or absence of a method
-        on the provided FakeClass instance. Asserts that 'instanceSyncMethod' exists and
-        'non_existent_method' does not.
+        Assertions
+        ----------
+        - Returns True for existing method 'instanceSyncMethod'
+        - Returns False for non-existent method 'non_existent_method'
         """
         reflect = ReflectionInstance(FakeClass())
         self.assertTrue(reflect.hasMethod('instanceSyncMethod'))
@@ -259,10 +373,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testCallMethod(self):
         """
-        Tests the callMethod function of the ReflectionInstance class.
+        Test ReflectionInstance.callMethod() synchronous method functionality.
 
-        This test verifies that calling the 'instanceSyncMethod' on a FakeClass instance
-        via ReflectionInstance.callMethod with arguments 2 and 3 returns the expected result (5).
+        Verifies that the callMethod method correctly invokes synchronous methods
+        on the wrapped instance with arguments and returns the expected result.
+        Tests method execution through reflection with parameter passing.
+
+        Assertions
+        ----------
+        - Calling 'instanceSyncMethod' with arguments 2 and 3 returns 5
         """
         reflect = ReflectionInstance(FakeClass())
         result = reflect.callMethod('instanceSyncMethod', 2, 3)
@@ -270,11 +389,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testCallAsyncMethod(self):
         """
-        Tests that the ReflectionInstance can correctly call an asynchronous method on an instance
-        and return the expected result.
+        Test ReflectionInstance.callMethod() asynchronous method functionality.
+
+        Verifies that the callMethod method correctly invokes asynchronous methods
+        on the wrapped instance with arguments and returns the expected result.
+        Tests async method execution through reflection with parameter passing.
 
-        This test creates a ReflectionInstance for a FakeClass object, invokes the 'instanceAsyncMethod'
-        asynchronously with arguments 2 and 3, and asserts that the result is 5.
+        Assertions
+        ----------
+        - Calling 'instanceAsyncMethod' with arguments 2 and 3 returns 5
         """
         reflect = ReflectionInstance(FakeClass())
         result = await reflect.callMethod('instanceAsyncMethod', 2, 3)
@@ -282,13 +405,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testSetMethod(self):
         """
-        Tests the ability of ReflectionInstance to set and call both synchronous and asynchronous methods dynamically.
-        This test:
-        - Defines a synchronous and an asynchronous mock method.
-        - Sets these methods on a ReflectionInstance of FakeClass using setMethod.
-        - Calls the synchronous method using callMethod and checks the result.
-        - Calls the asynchronous method using await callMethod and checks the result.
-        - Asserts that both methods return the expected sum of their arguments.
+        Test ReflectionInstance.setMethod() method functionality.
+
+        Verifies that the setMethod method can dynamically add both synchronous
+        and asynchronous methods to the wrapped instance. Tests the ability to
+        set custom methods and then call them through the reflection interface.
+
+        Assertions
+        ----------
+        - Synchronous mock method returns expected result (5) when called with arguments 2 and 3
+        - Asynchronous mock method returns expected result (5) when called with arguments 2 and 3
         """
 
         def mockSyncMethod(cls:FakeClass, num1, num2):
@@ -309,9 +435,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testRemoveMethod(self):
         """
-        Tests the removal of a dynamically added method from a ReflectionInstance.
-        This test adds a protected-like method to a ReflectionInstance of FakeClass,
-        verifies its existence, removes it, and then checks that it no longer exists.
+        Test ReflectionInstance.removeMethod() method functionality.
+
+        Verifies that the removeMethod method can successfully remove dynamically
+        added methods from the wrapped instance. Tests the process of adding a
+        method, confirming its existence, removing it, and validating its absence.
+
+        Assertions
+        ----------
+        - Method exists after being added (hasMethod returns True)
+        - Method no longer exists after removal (hasMethod returns False)
         """
         def _testProtectedMethod(cls:FakeClass, x, y):
             return x + y
@@ -327,10 +460,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetMethodSignature(self):
         """
-        Tests that the ReflectionInstance.getMethodSignature method correctly retrieves
-        the signature of the 'instanceSyncMethod' from the FakeClass instance.
-        Asserts that the returned signature string matches the expected format:
-        '(self, x: int, y: int) -> int'.
+        Test ReflectionInstance.getMethodSignature() method functionality.
+
+        Verifies that the getMethodSignature method correctly retrieves the
+        signature of a specified method from the wrapped instance. Tests
+        signature inspection and string representation of method parameters.
+
+        Assertions
+        ----------
+        - Signature of 'instanceSyncMethod' equals '(self, x: int, y: int) -> int'
         """
         reflect = ReflectionInstance(FakeClass())
         signature = reflect.getMethodSignature('instanceSyncMethod')
@@ -338,9 +476,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetMethods(self):
         """
-        Tests that the ReflectionInstance.getMethods() method correctly retrieves the names of all instance methods,
-        including both synchronous and asynchronous methods, from the FakeClass instance.
-        Asserts that 'instanceSyncMethod' and 'instanceAsyncMethod' are present in the returned methods list.
+        Test ReflectionInstance.getMethods() method functionality.
+
+        Verifies that the getMethods method correctly retrieves the names of all
+        instance methods from the wrapped instance, including both synchronous
+        and asynchronous methods. Tests comprehensive method discovery.
+
+        Assertions
+        ----------
+        - 'instanceSyncMethod' is present in the returned methods list
+        - 'instanceAsyncMethod' is present in the returned methods list
         """
         reflect = ReflectionInstance(FakeClass())
         methods = reflect.getMethods()
@@ -349,11 +494,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicMethods(self):
         """
-        Tests that the `getPublicMethods` method of `ReflectionInstance` returns only the public methods of a class instance.
-        Verifies that:
-            - Public methods (e.g., 'instanceSyncMethod') are included in the result.
-            - Protected methods (prefixed with a single underscore) are not included.
-            - Private methods (prefixed with double underscores) are not included.
+        Test ReflectionInstance.getPublicMethods() method functionality.
+
+        Verifies that the getPublicMethods method returns only public methods
+        of the wrapped instance, excluding protected and private methods. Tests
+        method visibility filtering based on Python naming conventions.
+
+        Assertions
+        ----------
+        - 'instanceSyncMethod' is included in the returned list
+        - '_protected_method' is not included in the returned list
+        - '__private_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_methods = reflect.getPublicMethods()
@@ -363,12 +514,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicSyncMethods(self):
         """
-        Test that ReflectionInstance.getPublicSyncMethods() returns only the names of public synchronous methods.
+        Test ReflectionInstance.getPublicSyncMethods() method functionality.
 
-        This test verifies that:
-        - Public synchronous methods (e.g., 'instanceSyncMethod') are included in the result.
-        - Protected methods (prefixed with a single underscore) are excluded.
-        - Private methods (prefixed with double underscores) are excluded.
+        Verifies that the getPublicSyncMethods method returns only the names of
+        public synchronous methods from the wrapped instance, excluding protected
+        and private methods. Tests synchronous method filtering with visibility.
+
+        Assertions
+        ----------
+        - 'instanceSyncMethod' is included in the returned list
+        - '_protected_method' is not included in the returned list
+        - '__private_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_sync_methods = reflect.getPublicSyncMethods()
@@ -378,11 +534,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicAsyncMethods(self):
         """
-        Test that ReflectionInstance.getPublicAsyncMethods() correctly identifies public asynchronous methods.
+        Test ReflectionInstance.getPublicAsyncMethods() method functionality.
+
+        Verifies that the getPublicAsyncMethods method correctly identifies and
+        returns only public asynchronous methods from the wrapped instance,
+        excluding protected and private async methods.
 
-        This test verifies that:
-        - Public async methods (e.g., 'instanceAsyncMethod') are included in the returned list.
-        - Protected (prefixed with a single underscore) and private (double underscore) async methods are not included.
+        Assertions
+        ----------
+        - 'instanceAsyncMethod' is included in the returned list
+        - '_protected_async_method' is not included in the returned list
+        - '__private_async_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_async_methods = reflect.getPublicAsyncMethods()
@@ -392,12 +554,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedMethods(self):
         """
-        Test that ReflectionInstance.getProtectedMethods() correctly identifies protected methods.
+        Test ReflectionInstance.getProtectedMethods() method functionality.
+
+        Verifies that the getProtectedMethods method correctly identifies and
+        returns only protected methods (prefixed with single underscore) from
+        the wrapped instance, excluding public and private methods.
 
-        This test verifies that:
-        - Protected methods (those prefixed with a single underscore) are included in the result.
-        - Public methods are not included.
-        - Private methods (those prefixed with double underscores) are not included.
+        Assertions
+        ----------
+        - '_protectedAsyncMethod' is included in the returned list
+        - 'instanceSyncMethod' is not included in the returned list
+        - '__privateSyncMethod' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_methods = reflect.getProtectedMethods()
@@ -407,11 +574,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedSyncMethods(self):
         """
-        Test that ReflectionInstance.getProtectedSyncMethods() correctly identifies protected synchronous methods.
+        Test ReflectionInstance.getProtectedSyncMethods() method functionality.
 
-        This test verifies that:
-        - Protected synchronous methods (e.g., methods prefixed with a single underscore) are included in the result.
-        - Asynchronous methods and private methods (e.g., methods prefixed with double underscores) are not included in the result.
+        Verifies that the getProtectedSyncMethods method correctly identifies and
+        returns only protected synchronous methods (prefixed with single underscore)
+        from the wrapped instance, excluding async and private methods.
+
+        Assertions
+        ----------
+        - '_protectedsyncMethod' is included in the returned list
+        - 'instanceAsyncMethod' is not included in the returned list
+        - '__privateSyncMethod' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_sync_methods = reflect.getProtectedSyncMethods()
@@ -421,12 +594,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedAsyncMethods(self):
         """
-        Test that ReflectionInstance.getProtectedAsyncMethods() correctly identifies protected asynchronous methods.
+        Test ReflectionInstance.getProtectedAsyncMethods() method functionality.
+
+        Verifies that the getProtectedAsyncMethods method correctly identifies and
+        returns only protected asynchronous methods (prefixed with single underscore)
+        from the wrapped instance, excluding public and private methods.
 
-        This test verifies that:
-        - The protected asynchronous method '_protectedAsyncMethod' is included in the returned list.
-        - The public synchronous method 'instanceSyncMethod' is not included.
-        - The private synchronous method '__privateSyncMethod' is not included.
+        Assertions
+        ----------
+        - '_protectedAsyncMethod' is included in the returned list
+        - 'instanceSyncMethod' is not included in the returned list
+        - '__privateSyncMethod' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_async_methods = reflect.getProtectedAsyncMethods()
@@ -436,12 +614,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateMethods(self):
         """
-        Test that `getPrivateMethods` correctly identifies private methods of a class instance.
+        Test ReflectionInstance.getPrivateMethods() method functionality.
+
+        Verifies that the getPrivateMethods method correctly identifies and
+        returns only private methods (prefixed with double underscores) from
+        the wrapped instance, excluding public and protected methods.
 
-        This test verifies that:
-        - The method `__privateSyncMethod` is included in the list of private methods.
-        - The method `instanceSyncMethod` (a public method) is not included.
-        - The method `_protectedAsyncMethod` (a protected method) is not included.
+        Assertions
+        ----------
+        - '__privateSyncMethod' is included in the returned list
+        - 'instanceSyncMethod' is not included in the returned list
+        - '_protectedAsyncMethod' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_methods = reflect.getPrivateMethods()
@@ -451,11 +634,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateSyncMethods(self):
         """
-        Test that ReflectionInstance.getPrivateSyncMethods correctly identifies private synchronous methods.
+        Test ReflectionInstance.getPrivateSyncMethods() method functionality.
 
-        This test verifies that:
-        - The method '__privateSyncMethod' is included in the list of private synchronous methods.
-        - The methods 'instanceAsyncMethod' and '_protectedAsyncMethod' are not included in the list.
+        Verifies that the getPrivateSyncMethods method correctly identifies and
+        returns only private synchronous methods (prefixed with double underscores)
+        from the wrapped instance, excluding async and protected methods.
+
+        Assertions
+        ----------
+        - '__privateSyncMethod' is included in the returned list
+        - 'instanceAsyncMethod' is not included in the returned list
+        - '_protectedAsyncMethod' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_sync_methods = reflect.getPrivateSyncMethods()
@@ -465,12 +654,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateAsyncMethods(self):
         """
-        Test that ReflectionInstance.getPrivateAsyncMethods correctly identifies private asynchronous methods.
+        Test ReflectionInstance.getPrivateAsyncMethods() method functionality.
+
+        Verifies that the getPrivateAsyncMethods method correctly identifies and
+        returns only private asynchronous methods (prefixed with double underscores)
+        from the wrapped instance, excluding public and protected methods.
 
-        This test verifies that:
-        - The method '__privateAsyncMethod' is included in the list of private async methods.
-        - The method 'instanceSyncMethod' is not included in the list.
-        - The method '_protectedAsyncMethod' is not included in the list.
+        Assertions
+        ----------
+        - '__privateAsyncMethod' is included in the returned list
+        - 'instanceSyncMethod' is not included in the returned list
+        - '_protectedAsyncMethod' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_async_methods = reflect.getPrivateAsyncMethods()
@@ -480,11 +674,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicClassMethods(self):
         """
-        Test that `getPublicClassMethods` returns only the public class methods of the given instance.
+        Test ReflectionInstance.getPublicClassMethods() method functionality.
+
+        Verifies that the getPublicClassMethods method correctly identifies and
+        returns only public class methods from the wrapped instance, excluding
+        protected and private class methods.
 
-        This test verifies that:
-        - Public class methods (e.g., 'classSyncMethod') are included in the result.
-        - Protected (e.g., '_protected_class_method') and private (e.g., '__private_class_method') class methods are excluded from the result.
+        Assertions
+        ----------
+        - 'classSyncMethod' is included in the returned list
+        - '_protected_class_method' is not included in the returned list
+        - '__private_class_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_class_methods = reflect.getPublicClassMethods()
@@ -494,11 +694,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicClassSyncMethods(self):
         """
-        Test that `getPublicClassSyncMethods` returns only public synchronous class methods.
+        Test ReflectionInstance.getPublicClassSyncMethods() method functionality.
 
-        This test verifies that:
-        - Public synchronous class methods (e.g., 'classSyncMethod') are included in the result.
-        - Protected (methods starting with a single underscore) and private (methods starting with double underscores) class methods are excluded from the result.
+        Verifies that the getPublicClassSyncMethods method correctly identifies and
+        returns only public synchronous class methods from the wrapped instance,
+        excluding protected and private class methods.
+
+        Assertions
+        ----------
+        - 'classSyncMethod' is included in the returned list
+        - '_protected_class_method' is not included in the returned list
+        - '__private_class_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_class_sync_methods = reflect.getPublicClassSyncMethods()
@@ -508,11 +714,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicClassAsyncMethods(self):
         """
-        Test that ReflectionInstance.getPublicClassAsyncMethods() correctly identifies public asynchronous class methods.
+        Test ReflectionInstance.getPublicClassAsyncMethods() method functionality.
+
+        Verifies that the getPublicClassAsyncMethods method correctly identifies and
+        returns only public asynchronous class methods from the wrapped instance,
+        excluding protected and private async class methods.
 
-        This test verifies that:
-        - Public async class methods (e.g., 'classAsyncMethod') are included in the returned list.
-        - Protected (prefixed with a single underscore) and private (prefixed with double underscores) async class methods are not included.
+        Assertions
+        ----------
+        - 'classAsyncMethod' is included in the returned list
+        - '_protected_class_async_method' is not included in the returned list
+        - '__private_class_async_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_class_async_methods = reflect.getPublicClassAsyncMethods()
@@ -522,12 +734,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedClassMethods(self):
         """
-        Test that ReflectionInstance.getProtectedClassMethods() correctly identifies protected class methods.
+        Test ReflectionInstance.getProtectedClassMethods() method functionality.
 
-        This test verifies that:
-        - Protected class methods (those prefixed with a single underscore) are included in the result.
-        - Public class methods are not included.
-        - Private class methods (those prefixed with double underscores) are not included.
+        Verifies that the getProtectedClassMethods method correctly identifies and
+        returns only protected class methods (prefixed with single underscore) from
+        the wrapped instance, excluding public and private class methods.
+
+        Assertions
+        ----------
+        - '_classMethodProtected' is included in the returned list
+        - 'classSyncMethod' is not included in the returned list
+        - '__classMethodPrivate' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_class_methods = reflect.getProtectedClassMethods()
@@ -537,13 +754,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedClassSyncMethods(self):
         """
-        Test that ReflectionInstance.getProtectedClassSyncMethods correctly identifies
-        protected (single underscore-prefixed) synchronous class methods.
+        Test ReflectionInstance.getProtectedClassSyncMethods() method functionality.
+
+        Verifies that the getProtectedClassSyncMethods method correctly identifies and
+        returns only protected synchronous class methods (prefixed with single underscore)
+        from the wrapped instance, excluding public and private class methods.
 
-        Asserts that:
-            - '_classMethodProtected' is included in the returned list.
-            - 'classSyncMethod' (public) is not included.
-            - '__classSyncMethodPrivate' (private, double underscore) is not included.
+        Assertions
+        ----------
+        - '_classMethodProtected' is included in the returned list
+        - 'classSyncMethod' is not included in the returned list
+        - '__classSyncMethodPrivate' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_class_sync_methods = reflect.getProtectedClassSyncMethods()
@@ -553,12 +774,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedClassAsyncMethods(self):
         """
-        Test that ReflectionInstance correctly retrieves protected asynchronous class methods.
+        Test ReflectionInstance.getProtectedClassAsyncMethods() method functionality.
+
+        Verifies that the getProtectedClassAsyncMethods method correctly identifies and
+        returns only protected asynchronous class methods (prefixed with single underscore)
+        from the wrapped instance, excluding public and private async class methods.
 
-        This test verifies that:
-        - Protected async class methods (those prefixed with a single underscore) are included in the result.
-        - Public async class methods are not included.
-        - Private async class methods (those prefixed with double underscores) are not included.
+        Assertions
+        ----------
+        - '_classAsyncMethodProtected' is included in the returned list
+        - 'classAsyncMethod' is not included in the returned list
+        - '__classAsyncMethodPrivate' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_class_async_methods = reflect.getProtectedClassAsyncMethods()
@@ -568,12 +794,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateClassMethods(self):
         """
-        Test that `getPrivateClassMethods` correctly identifies private class methods.
+        Test ReflectionInstance.getPrivateClassMethods() method functionality.
 
-        This test verifies that:
-        - The private class method '__classMethodPrivate' is included in the returned list.
-        - The public class method 'classSyncMethod' is not included.
-        - The protected class method '_classMethodProtected' is not included.
+        Verifies that the getPrivateClassMethods method correctly identifies and
+        returns only private class methods (prefixed with double underscores) from
+        the wrapped instance, excluding public and protected class methods.
+
+        Assertions
+        ----------
+        - '__classMethodPrivate' is included in the returned list
+        - 'classSyncMethod' is not included in the returned list
+        - '_classMethodProtected' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_class_methods = reflect.getPrivateClassMethods()
@@ -583,12 +814,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateClassSyncMethods(self):
         """
-        Test that ReflectionInstance.getPrivateClassSyncMethods() correctly identifies private class-level synchronous methods.
+        Test ReflectionInstance.getPrivateClassSyncMethods() method functionality.
+
+        Verifies that the getPrivateClassSyncMethods method correctly identifies and
+        returns only private synchronous class methods (prefixed with double underscores)
+        from the wrapped instance, excluding public and protected class methods.
 
-        This test verifies that:
-        - The private class method '__classMethodPrivate' is included in the returned list.
-        - The public class method 'classSyncMethod' is not included.
-        - The protected class method '_classMethodProtected' is not included.
+        Assertions
+        ----------
+        - '__classMethodPrivate' is included in the returned list
+        - 'classSyncMethod' is not included in the returned list
+        - '_classMethodProtected' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_class_methods = reflect.getPrivateClassSyncMethods()
@@ -598,12 +834,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateClassAsyncMethods(self):
         """
-        Test that ReflectionInstance correctly retrieves private class asynchronous methods.
+        Test ReflectionInstance.getPrivateClassAsyncMethods() method functionality.
 
-        This test verifies that:
-        - The private async method '__classAsyncMethodPrivate' is included in the list of private class async methods.
-        - The public async method 'classAsyncMethod' is not included.
-        - The protected async method '_classAsyncMethodProtected' is not included.
+        Verifies that the getPrivateClassAsyncMethods method correctly identifies and
+        returns only private asynchronous class methods (prefixed with double underscores)
+        from the wrapped instance, excluding public and protected async class methods.
+
+        Assertions
+        ----------
+        - '__classAsyncMethodPrivate' is included in the returned list
+        - 'classAsyncMethod' is not included in the returned list
+        - '_classAsyncMethodProtected' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_class_async_methods = reflect.getPrivateClassAsyncMethods()
@@ -613,13 +854,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicStaticMethods(self):
         """
-        Tests that the `getPublicStaticMethods` method of `ReflectionInstance` correctly retrieves
-        the names of public static methods from the `FakeClass` instance.
+        Test ReflectionInstance.getPublicStaticMethods() method functionality.
+
+        Verifies that the getPublicStaticMethods method correctly identifies and
+        returns the names of public static methods from the wrapped instance,
+        excluding protected and private static methods.
 
-        Asserts that:
-            - 'staticMethod' is included in the list of public static methods.
-            - 'staticAsyncMethod' is included in the list of public static methods.
-            - 'static_async_method' is not included in the list of public static methods.
+        Assertions
+        ----------
+        - 'staticMethod' is included in the returned list
+        - 'staticAsyncMethod' is included in the returned list
+        - 'static_async_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_static_methods = reflect.getPublicStaticMethods()
@@ -629,11 +874,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicStaticSyncMethods(self):
         """
-        Test that ReflectionInstance.getPublicStaticSyncMethods() correctly identifies public static synchronous methods.
+        Test ReflectionInstance.getPublicStaticSyncMethods() method functionality.
+
+        Verifies that the getPublicStaticSyncMethods method correctly identifies and
+        returns only public static synchronous methods from the wrapped instance,
+        excluding async and non-public static methods.
 
-        This test verifies that:
-        - 'staticMethod' (a public static synchronous method) is included in the returned list.
-        - 'staticAsyncMethod' and 'static_async_method' (presumed to be static asynchronous methods) are not included in the returned list.
+        Assertions
+        ----------
+        - 'staticMethod' is included in the returned list
+        - 'staticAsyncMethod' is not included in the returned list
+        - 'static_async_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_static_sync_methods = reflect.getPublicStaticSyncMethods()
@@ -643,11 +894,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicStaticAsyncMethods(self):
         """
-        Test that ReflectionInstance.getPublicStaticAsyncMethods() correctly identifies public static asynchronous methods.
+        Test ReflectionInstance.getPublicStaticAsyncMethods() method functionality.
 
-        This test verifies that:
-        - 'staticAsyncMethod' is included in the list of public static async methods.
-        - 'staticMethod' and 'static_async_method' are not included in the list.
+        Verifies that the getPublicStaticAsyncMethods method correctly identifies and
+        returns only public static asynchronous methods from the wrapped instance,
+        excluding sync and non-public static methods.
+
+        Assertions
+        ----------
+        - 'staticAsyncMethod' is included in the returned list
+        - 'staticMethod' is not included in the returned list
+        - 'static_async_method' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_static_async_methods = reflect.getPublicStaticAsyncMethods()
@@ -657,12 +914,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedStaticMethods(self):
         """
-        Test that ReflectionInstance.getProtectedStaticMethods() correctly identifies protected static methods.
+        Test ReflectionInstance.getProtectedStaticMethods() method functionality.
+
+        Verifies that the getProtectedStaticMethods method correctly identifies and
+        returns only protected static methods (prefixed with single underscore) from
+        the wrapped instance, excluding public and private static methods.
 
-        This test verifies that:
-        - The protected static method '_staticMethodProtected' is included in the returned list.
-        - The public static method 'staticMethod' is not included.
-        - The private static method '__staticMethodPrivate' is not included.
+        Assertions
+        ----------
+        - '_staticMethodProtected' is included in the returned list
+        - 'staticMethod' is not included in the returned list
+        - '__staticMethodPrivate' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_static_methods = reflect.getProtectedStaticMethods()
@@ -672,12 +934,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedStaticSyncMethods(self):
         """
-        Test that ReflectionInstance.getProtectedStaticSyncMethods() correctly identifies
-        protected static synchronous methods of the FakeClass.
+        Test ReflectionInstance.getProtectedStaticSyncMethods() method functionality.
 
-        Asserts that:
-            - '_staticMethodProtected' is included in the returned list.
-            - 'staticAsyncMethod' and '__staticMethodPrivate' are not included.
+        Verifies that the getProtectedStaticSyncMethods method correctly identifies and
+        returns only protected static synchronous methods (prefixed with single underscore)
+        from the wrapped instance, excluding async and non-protected static methods.
+
+        Assertions
+        ----------
+        - '_staticMethodProtected' is included in the returned list
+        - 'staticAsyncMethod' is not included in the returned list
+        - '__staticMethodPrivate' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_static_sync_methods = reflect.getProtectedStaticSyncMethods()
@@ -687,12 +954,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedStaticAsyncMethods(self):
         """
-        Test that ReflectionInstance correctly identifies protected static asynchronous methods.
+        Test ReflectionInstance.getProtectedStaticAsyncMethods() method functionality.
+
+        Verifies that the getProtectedStaticAsyncMethods method correctly identifies and
+        returns only protected static asynchronous methods (prefixed with single underscore)
+        from the wrapped instance, excluding public and private static methods.
 
-        This test verifies that:
-        - The protected static async method '_staticAsyncMethodProtected' is included in the list returned by getProtectedStaticAsyncMethods().
-        - The public static method 'staticMethod' is not included in the list.
-        - The private static method '__staticMethodPrivate' is not included in the list.
+        Assertions
+        ----------
+        - '_staticAsyncMethodProtected' is included in the returned list
+        - 'staticMethod' is not included in the returned list
+        - '__staticMethodPrivate' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_static_async_methods = reflect.getProtectedStaticAsyncMethods()
@@ -702,9 +974,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateStaticMethods(self):
         """
-        Test that `getPrivateStaticMethods` correctly identifies and returns the names of private static methods
-        from the reflected class instance. Ensures that private static methods (those with double underscores)
-        are included, while protected (single underscore) and public static methods are excluded from the result.
+        Test ReflectionInstance.getPrivateStaticMethods() method functionality.
+
+        Verifies that the getPrivateStaticMethods method correctly identifies and
+        returns only private static methods (prefixed with double underscores) from
+        the wrapped instance, excluding protected and public static methods.
+
+        Assertions
+        ----------
+        - '__staticMethodPrivate' is included in the returned list
+        - 'staticMethod' is not included in the returned list
+        - '_staticMethodProtected' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_static_methods = reflect.getPrivateStaticMethods()
@@ -714,11 +994,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateStaticSyncMethods(self):
         """
-        Test that ReflectionInstance.getPrivateStaticSyncMethods() correctly identifies private static synchronous methods.
+        Test ReflectionInstance.getPrivateStaticSyncMethods() method functionality.
+
+        Verifies that the getPrivateStaticSyncMethods method correctly identifies and
+        returns only private static synchronous methods (prefixed with double underscores)
+        from the wrapped instance, excluding public and protected static methods.
 
-        This test verifies that:
-        - The method '__staticMethodPrivate' (a private static sync method) is included in the returned list.
-        - The methods 'staticMethod' (public) and '_staticMethodProtected' (protected) are not included in the returned list.
+        Assertions
+        ----------
+        - '__staticMethodPrivate' is included in the returned list
+        - 'staticMethod' is not included in the returned list
+        - '_staticMethodProtected' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_static_sync_methods = reflect.getPrivateStaticSyncMethods()
@@ -728,11 +1014,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateStaticAsyncMethods(self):
         """
-        Test that ReflectionInstance correctly identifies private static asynchronous methods.
+        Test ReflectionInstance.getPrivateStaticAsyncMethods() method functionality.
+
+        Verifies that the getPrivateStaticAsyncMethods method correctly identifies and
+        returns only private static asynchronous methods (prefixed with double underscores)
+        from the wrapped instance, excluding public and protected static async methods.
 
-        This test verifies that:
-        - The list of private static async methods includes '__staticAsyncMethodPrivate'.
-        - The list does not include 'staticAsyncMethod' (public) or '_staticAsyncMethodProtected' (protected).
+        Assertions
+        ----------
+        - '__staticAsyncMethodPrivate' is included in the returned list
+        - 'staticAsyncMethod' is not included in the returned list
+        - '_staticAsyncMethodProtected' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_static_async_methods = reflect.getPrivateStaticAsyncMethods()
@@ -742,8 +1034,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetDunderMethods(self):
         """
-        Test that the getDunderMethods method of ReflectionInstance returns a list containing
-        dunder (double underscore) methods of the given instance, such as '__init__' and '__class__'.
+        Test ReflectionInstance.getDunderMethods() method functionality.
+
+        Verifies that the getDunderMethods method correctly identifies and returns
+        dunder (double underscore) methods from the wrapped instance. Tests the
+        detection of special Python methods with double underscore prefix and suffix.
+
+        Assertions
+        ----------
+        - '__init__' is present in the returned list
+        - '__class__' is present in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         dunder_methods = reflect.getDunderMethods()
@@ -752,11 +1052,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetMagicMethods(self):
         """
-        Tests that the ReflectionInstance.getMagicMethods() method correctly retrieves
-        the list of magic methods from the given FakeClass instance.
+        Test ReflectionInstance.getMagicMethods() method functionality.
+
+        Verifies that the getMagicMethods method correctly identifies and returns
+        magic methods (special Python methods with double underscores) from the
+        wrapped instance. Tests the detection of commonly expected magic methods.
 
-        Asserts that commonly expected magic methods such as '__init__' and '__class__'
-        are present in the returned list.
+        Assertions
+        ----------
+        - '__init__' is present in the returned list
+        - '__class__' is present in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         magic_methods = reflect.getMagicMethods()
@@ -765,8 +1070,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProperties(self):
         """
-        Test that ReflectionInstance.getProperties() returns all expected properties,
-        including public, protected, and private computed properties of the target class.
+        Test ReflectionInstance.getProperties() method functionality.
+
+        Verifies that the getProperties method correctly identifies and returns all
+        properties (computed properties) from the wrapped instance, including public,
+        protected, and private properties.
+
+        Assertions
+        ----------
+        - 'computed_public_property' is present in the returned list
+        - '_computed_property_protected' is present in the returned list
+        - '__computed_property_private' is present in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         properties = reflect.getProperties()
@@ -776,13 +1090,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPublicProperties(self):
         """
-        Tests that the `getPublicProperties` method of `ReflectionInstance` correctly identifies
-        and returns only the public properties of a given class instance.
+        Test ReflectionInstance.getPublicProperties() method functionality.
 
-        Verifies that:
-            - Public properties (e.g., 'computed_public_property') are included in the result.
-            - Protected (e.g., '_computed_property_protected') and private (e.g., '__computed_property_private') 
-              properties are not included in the result.
+        Verifies that the getPublicProperties method correctly identifies and returns
+        only public properties from the wrapped instance, excluding protected and
+        private properties based on Python naming conventions.
+
+        Assertions
+        ----------
+        - 'computed_public_property' is included in the returned list
+        - '_computed_property_protected' is not included in the returned list
+        - '__computed_property_private' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         public_properties = reflect.getPublicProperties()
@@ -792,12 +1110,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProtectedProperties(self):
         """
-        Test that ReflectionInstance.getProtectedProperties() correctly identifies protected properties.
+        Test ReflectionInstance.getProtectedProperties() method functionality.
+
+        Verifies that the getProtectedProperties method correctly identifies and returns
+        only protected properties (prefixed with single underscore) from the wrapped
+        instance, excluding public and private properties.
 
-        This test verifies that:
-        - Protected properties (those prefixed with a single underscore) are included in the result.
-        - Public properties are not included.
-        - Private properties (those prefixed with double underscores) are not included.
+        Assertions
+        ----------
+        - '_computed_property_protected' is included in the returned list
+        - 'computed_public_property' is not included in the returned list
+        - '__computed_property_private' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         protected_properties = reflect.getProtectedProperties()
@@ -807,11 +1130,17 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPrivateProperties(self):
         """
-        Test that ReflectionInstance.getPrivateProperties() correctly identifies private properties.
+        Test ReflectionInstance.getPrivateProperties() method functionality.
+
+        Verifies that the getPrivateProperties method correctly identifies and returns
+        only private properties (prefixed with double underscores) from the wrapped
+        instance, excluding public and protected properties.
 
-        This test verifies that:
-        - Private properties (those with double underscores) are included in the result.
-        - Public and protected properties are not included in the result.
+        Assertions
+        ----------
+        - '__computed_property_private' is included in the returned list
+        - 'computed_public_property' is not included in the returned list
+        - '_computed_property_protected' is not included in the returned list
         """
         reflect = ReflectionInstance(FakeClass())
         private_properties = reflect.getPrivateProperties()
@@ -821,11 +1150,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetProperty(self):
         """
-        Tests that the ReflectionInstance.getProperty method correctly retrieves the value of a computed public property
-        from an instance of FakeClass.
+        Test ReflectionInstance.getProperty() method functionality.
 
-        Asserts that the value returned by getProperty for 'computed_public_property' matches the actual property value
-        from a new FakeClass instance.
+        Verifies that the getProperty method correctly retrieves the value of a
+        computed property from the wrapped instance. Tests property value access
+        through reflection and compares with direct property access.
+
+        Assertions
+        ----------
+        - Property value retrieved through reflection equals direct property access value
         """
         reflect = ReflectionInstance(FakeClass())
         value = reflect.getProperty('computed_public_property')
@@ -833,9 +1166,15 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPropertySignature(self):
         """
-        Tests that the `getPropertySignature` method of `ReflectionInstance` correctly retrieves
-        the signature of the specified property ('computed_public_property') from a `FakeClass` instance.
-        Asserts that the returned signature string matches the expected format '(self) -> str'.
+        Test ReflectionInstance.getPropertySignature() method functionality.
+
+        Verifies that the getPropertySignature method correctly retrieves the
+        signature of a specified property from the wrapped instance. Tests
+        property signature inspection and string representation.
+
+        Assertions
+        ----------
+        - Signature of 'computed_public_property' equals '(self) -> str'
         """
         reflect = ReflectionInstance(FakeClass())
         signature = reflect.getPropertySignature('computed_public_property')
@@ -843,20 +1182,31 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetPropertyDocstring(self):
         """
-        Tests that the getPropertyDocstring method of ReflectionInstance correctly retrieves
-        the docstring for the specified property ('computed_public_property') of the FakeClass instance.
-        Asserts that the returned docstring contains the expected description.
+        Test ReflectionInstance.getPropertyDocstring() method functionality.
+
+        Verifies that the getPropertyDocstring method correctly retrieves the
+        docstring for a specified property from the wrapped instance. Tests
+        property documentation extraction.
+
+        Assertions
+        ----------
+        - Docstring for 'computed_public_property' contains 'Returns a string indicating this is a public'
         """
         reflect = ReflectionInstance(FakeClass())
         docstring = reflect.getPropertyDocstring('computed_public_property')
-        self.assertIn('Returns the string "public" as', docstring)
+        self.assertIn('Returns a string indicating this is a public', docstring)
 
     async def testGetConstructorDependencies(self):
         """
-        Tests that the `getConstructorDependencies` method of `ReflectionInstance` returns an instance of `ClassDependency`.
+        Test ReflectionInstance.getConstructorDependencies() method functionality.
 
-        This test creates a `ReflectionInstance` for a `FakeClass` object, retrieves its constructor dependencies,
-        and asserts that the returned value is an instance of `ClassDependency`.
+        Verifies that the getConstructorDependencies method returns an instance
+        of ClassDependency containing the constructor dependencies of the wrapped
+        instance's class. Tests dependency analysis for class constructors.
+
+        Assertions
+        ----------
+        - Returned value is an instance of ClassDependency
         """
         reflect = ReflectionInstance(FakeClass())
         dependencies = reflect.getConstructorDependencies()
@@ -864,14 +1214,18 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
     async def testGetMethodDependencies(self):
         """
-        Test that the `getMethodDependencies` method of `ReflectionInstance` correctly resolves
-        the dependencies of the 'instanceSyncMethod' in `FakeClass`.
+        Test ReflectionInstance.getMethodDependencies() method functionality.
+
+        Verifies that the getMethodDependencies method correctly resolves the
+        dependencies of a specified method from the wrapped instance. Tests
+        method parameter type analysis and dependency resolution.
 
-        This test verifies that:
-          - The method dependencies 'x' and 'y' are present in the resolved dependencies.
-          - Both 'x' and 'y' are identified as integers (`int`), with the correct class name, module name,
-            type, and full class path.
-          - There are no unresolved dependencies.
+        Assertions
+        ----------
+        - 'x' parameter is present in resolved dependencies
+        - 'y' parameter is present in resolved dependencies
+        - Both parameters are identified as int type with correct metadata
+        - No unresolved dependencies exist
         """
         reflect = ReflectionInstance(FakeClass())
         method_deps = reflect.getMethodDependencies('instanceSyncMethod')