Fix: Object cache was removing objects properly.

Continue to update test to use unittest.

llvm/__init__.py

@@ -128,8 +128,9 @@ class _ObjectCache(type):
     @staticmethod
     def forget(obj):
         objid = _core.PyCObjectVoidPtrToPyLong(obj.ptr)
-        if objid in _ObjectCache.__instances:
+        key = "%s:%d" % (type(obj).__name__, objid)
-            del _ObjectCache.__instances[objid]
+        if key in _ObjectCache.__instances:
+            del _ObjectCache.__instances[key]
 
 
 #===----------------------------------------------------------------------===

test/objcache.py

@@ -2,107 +2,106 @@
 
 from llvm.core import *
 
-def check(a, b):
+import logging, unittest
-    if a is b:
-        print("OK")
-    else:
-        print("FAIL")
 
-def check_isnot(a, b):
+class TestObjCache(unittest.TestCase):
-    if not (a is b):
+    def test_objcache(self):
-        print("OK")
+        logging.debug("Testing module aliasing ..")
-    else:
+        m1 = Module.new('a')
-        print("FAIL")
+        t = Type.int()
+        ft = Type.function(t, [t])
+        f1 = m1.add_function(ft, "func")
+        m2 = f1.module
+        self.assertIs(m1, m2)
 
-print("Testing module aliasing ..", end=' ')
+        logging.debug("Testing global vairable aliasing 1 .. ")
-m1 = Module.new('a')
+        gv1 = GlobalVariable.new(m1, t, "gv")
-t = Type.int()
+        gv2 = GlobalVariable.get(m1, "gv")
-ft = Type.function(t, [t])
+        self.assertIs(gv1, gv2)
-f1 = m1.add_function(ft, "func")
-m2 = f1.module
-check(m1, m2)
 
-print("Testing global vairable aliasing 1 .. ", end=' ')
+        logging.debug("Testing global vairable aliasing 2 .. ")
-gv1 = GlobalVariable.new(m1, t, "gv")
+        gv3 = m1.global_variables[0]
-gv2 = GlobalVariable.get(m1, "gv")
+        self.assertIs(gv1, gv3)
-check(gv1, gv2)
 
-print("Testing global vairable aliasing 2 .. ", end=' ')
+        logging.debug("Testing global vairable aliasing 3 .. ")
-gv3 = m1.global_variables[0]
-check(gv1, gv3)
 
-print("Testing global vairable aliasing 3 .. ", end=' ')
+        gv2 = None
-gv2 = None
+        gv3 = None
-gv3 = None
-gv1.delete()
-gv4 = GlobalVariable.new(m1, t, "gv")
-check_isnot(gv1, gv4)
 
-print("Testing function aliasing 1 ..", end=' ')
+        gv1.delete()
-b1 = f1.append_basic_block('entry')
+        gv4 = GlobalVariable.new(m1, t, "gv")
-f2 = b1.function
-check(f1, f2)
 
-print("Testing function aliasing 2 ..", end=' ')
+        self.assertIsNot(gv1, gv4)
-f3 = m1.get_function_named("func")
-check(f1, f3)
 
-print("Testing function aliasing 3 ..", end=' ')
+        logging.debug("Testing function aliasing 1 ..")
-f4 = Function.get_or_insert(m1, ft, "func")
+        b1 = f1.append_basic_block('entry')
-check(f1, f4)
+        f2 = b1.function
+        self.assertIs(f1, f2)
 
-print("Testing function aliasing 4 ..", end=' ')
+        logging.debug("Testing function aliasing 2 ..")
-f5 = Function.get(m1, "func")
+        f3 = m1.get_function_named("func")
-check(f1, f5)
+        self.assertIs(f1, f3)
 
-print("Testing function aliasing 5 ..", end=' ')
+        logging.debug("Testing function aliasing 3 ..")
-f6 = m1.get_or_insert_function(ft, "func")
+        f4 = Function.get_or_insert(m1, ft, "func")
-check(f1, f6)
+        self.assertIs(f1, f4)
 
-print("Testing function aliasing 6 ..", end=' ')
+        logging.debug("Testing function aliasing 4 ..")
-f7 = m1.functions[0]
+        f5 = Function.get(m1, "func")
-check(f1, f7)
+        self.assertIs(f1, f5)
 
-print("Testing argument aliasing .. ", end=' ')
+        logging.debug("Testing function aliasing 5 ..")
-a1 = f1.args[0]
+        f6 = m1.get_or_insert_function(ft, "func")
-a2 = f1.args[0]
+        self.assertIs(f1, f6)
-check(a1, a2)
 
-print("Testing basic block aliasing 1 .. ", end=' ')
+        logging.debug("Testing function aliasing 6 ..")
-b2 = f1.basic_blocks[0]
+        f7 = m1.functions[0]
-check(b1, b2)
+        self.assertIs(f1, f7)
 
-print("Testing basic block aliasing 2 .. ", end=' ')
+        logging.debug("Testing argument aliasing .. ")
-b3 = f1.get_entry_basic_block()
+        a1 = f1.args[0]
-check(b1, b3)
+        a2 = f1.args[0]
+        self.assertIs(a1, a2)
 
-print("Testing basic block aliasing 3 .. ", end=' ')
+        logging.debug("Testing basic block aliasing 1 .. ")
-b31 = f1.entry_basic_block
+        b2 = f1.basic_blocks[0]
-check(b1, b31)
+        self.assertIs(b1, b2)
 
-print("Testing basic block aliasing 4 .. ", end=' ')
+        logging.debug("Testing basic block aliasing 2 .. ")
-bldr = Builder.new(b1)
+        b3 = f1.get_entry_basic_block()
-b4 = bldr.basic_block
+        self.assertIs(b1, b3)
-check(b1, b4)
 
-print("Testing basic block aliasing 5 .. ", end=' ')
+        logging.debug("Testing basic block aliasing 3 .. ")
-i1 = bldr.ret_void()
+        b31 = f1.entry_basic_block
-b5 = i1.basic_block
+        self.assertIs(b1, b31)
-check(b1, b5)
 
-print("Testing instruction aliasing 1 .. ", end=' ')
+        logging.debug("Testing basic block aliasing 4 .. ")
-i2 = b5.instructions[0]
+        bldr = Builder.new(b1)
-check(i1, i2)
+        b4 = bldr.basic_block
+        self.assertIs(b1, b4)
 
-# phi node
+        logging.debug("Testing basic block aliasing 5 .. ")
-phi = bldr.phi(t)
+        i1 = bldr.ret_void()
-phi.add_incoming(f1.args[0], b1)
+        b5 = i1.basic_block
-v2 = phi.get_incoming_value(0)
+        self.assertIs(b1, b5)
-b6 = phi.get_incoming_block(0)
 
-print("Testing PHI / basic block aliasing 5 .. ", end=' ')
+        logging.debug("Testing instruction aliasing 1 .. ")
-check(b1, b6)
+        i2 = b5.instructions[0]
+        self.assertIs(i1, i2)
 
-print("Testing PHI / value aliasing .. ", end=' ')
+        # phi node
-check(f1.args[0], v2)
+        phi = bldr.phi(t)
+        phi.add_incoming(f1.args[0], b1)
+        v2 = phi.get_incoming_value(0)
+        b6 = phi.get_incoming_block(0)
 
+        logging.debug("Testing PHI / basic block aliasing 5 .. ")
+        self.assertIs(b1, b6)
+
+        logging.debug("Testing PHI / value aliasing .. ")
+        self.assertIs(f1.args[0], v2)
+
+
+
+if __name__ == '__main__':
+    unittest.main()