1 files changed, 190 insertions, 0 deletions
diff --git a/tests/glibext/hashable.py b/tests/glibext/hashable.py
new file mode 100644
index 0000000..07f22e3
--- /dev/null
+++ b/tests/glibext/hashable.py
@@ -0,0 +1,190 @@
+
+import gi
+
+from chrysacase import ChrysalideTestCase
+from gi.repository import GObject
+from pychrysalide.glibext import HashableObject
+
+
+class TestStringBuilder(ChrysalideTestCase):
+    """Test cases for pychrysalide.glibext.HashableObject."""
+
+
+    def testHashableObjectCreation(self):
+        """Create objects with HashableObject interface."""
+
+        with self.assertRaisesRegex(NotImplementedError, 'HashableObject can not be constructed'):
+
+            ho = HashableObject()
+
+
+        class NewHashableObjectImplem(gi._gi.GObject, HashableObject):
+            pass
+
+        nho = NewHashableObjectImplem()
+
+        self.assertIsNotNone(nho)
+
+
+        class NewHashableObjectImplem2(GObject.Object, HashableObject):
+            pass
+
+        nho2 = NewHashableObjectImplem()
+
+        self.assertIsNotNone(nho2)
+
+
+    def testHashableObjectMethods(self):
+        """Test the HashableObject methods."""
+
+        class BasicHashableObjectImplem(gi._gi.GObject, HashableObject):
+
+            def __init__(self, val):
+                super().__init__()
+                self._val = val
+
+            def _hash(self):
+                return self._val
+
+        value = 1234
+
+        ho = BasicHashableObjectImplem(value)
+
+        self.assertEqual(hash(ho), value)
+
+
+        class BasicHashableObjectImplem2(GObject.Object, HashableObject):
+
+            def __init__(self, val):
+                super().__init__()
+                self._val = val
+
+            def _hash(self):
+                return self._val
+
+        value = 5678
+
+        ho2 = BasicHashableObjectImplem2(value)
+
+        self.assertEqual(hash(ho2), value)
+
+
+    def testCascadingHashableObjectImplementations(self):
+        """Request the hash from the object parent for a full computing."""
+
+
+        class CascadingHashableObjectFullImplemA(GObject.Object, HashableObject):
+
+            def _hash(self):
+                return 1
+
+        class CascadingHashableObjectFullImplemB(CascadingHashableObjectFullImplemA, HashableObject):
+
+            def _hash(self):
+                return super()._hash() * 2
+
+        class CascadingHashableObjectFullImplemC(CascadingHashableObjectFullImplemB, HashableObject):
+
+            def _hash(self):
+                return super()._hash() * 3
+
+
+        obj_a = CascadingHashableObjectFullImplemA()
+
+        obj_b = CascadingHashableObjectFullImplemB()
+
+        obj_c = CascadingHashableObjectFullImplemC()
+
+
+        self.assertEqual(hash(obj_a), 1)
+        self.assertEqual(hash(obj_b), 2)
+        self.assertEqual(hash(obj_c), 6)
+
+
+        class CascadingHashableObjectPartialImplemA(GObject.Object, HashableObject):
+
+            def _hash(self):
+                return 1
+
+        class CascadingHashableObjectPartialImplemB(CascadingHashableObjectPartialImplemA):
+            pass
+
+        class CascadingHashableObjectPartialImplemC(CascadingHashableObjectPartialImplemB, HashableObject):
+
+            def _hash(self):
+                return super()._hash() * 3
+
+
+        obj_a = CascadingHashableObjectPartialImplemA()
+
+        obj_b = CascadingHashableObjectPartialImplemB()
+
+        obj_c = CascadingHashableObjectPartialImplemC()
+
+
+        self.assertEqual(hash(obj_a), 1)
+        self.assertEqual(hash(obj_b), 1)
+        self.assertEqual(hash(obj_c), 3)
+
+
+    def testHashableObjectExceptions(self):
+        """Raise exceptions from the HashableObject interface as expected."""
+
+        class BadHashableObjectImplem(GObject.Object, HashableObject):
+            pass
+
+        obj = BadHashableObjectImplem()
+
+
+        with self.assertRaisesRegex(NotImplementedError, "method implementation is missing for '_hash'"):
+
+            h = hash(obj)
+
+
+        with self.assertRaisesRegex(TypeError, 'object parent does not implement the HashableObject interface'):
+
+            h = obj.parent_hash()
+
+
+        class BadHashableObjectImplem2(GObject.Object, HashableObject):
+
+            def _hash(self):
+                return 'AAA'
+
+        obj2 = BadHashableObjectImplem2()
+
+
+        with self.assertRaisesRegex(TypeError, 'computed hash value has to be an unsigned integer'):
+
+            h = hash(obj2)
+
+
+        class BadHashableObjectImplem3a(GObject.Object, HashableObject):
+
+            def _hash(self):
+                return 123
+
+        class BadHashableObjectImplem3b(BadHashableObjectImplem3a, HashableObject):
+
+            def _hash(self):
+                return self.parent_hash()
+
+        obj3 = BadHashableObjectImplem3b()
+
+
+        with self.assertRaisesRegex(RuntimeError, 'object parent is not a native type'):
+
+            h = hash(obj3)
+
+
+        class BadHashableObjectImplem4(GObject.Object, HashableObject):
+
+            def _hash(self):
+                raise Exception('error')
+
+        obj4 = BadHashableObjectImplem4()
+
+
+        with self.assertRaisesRegex(Exception, 'error'):
+
+            h = hash(obj4)