def testRefCountIncRefDecRef(self):
        frees = []
        allocator = GetAllocatingTestAllocator([], frees)
        mapper = PythonMapper(allocator)
        deallocTypes = CreateTypes(mapper)

        obj1 = object()
        ptr = mapper.Store(obj1)
        self.assertEquals(mapper.HasPtr(ptr), True)

        mapper.IncRef(ptr)
        self.assertEquals(mapper.RefCount(ptr), 2, "unexpected refcount")
        self.assertEquals(mapper.HasPtr(ptr), True)

        del frees[:]
        mapper.DecRef(ptr)
        self.assertEquals(mapper.RefCount(ptr), 1, "unexpected refcount")
        self.assertEquals(mapper.HasPtr(ptr), True)
        self.assertEquals(frees, [], "unexpected deallocations")

        mapper.DecRef(ptr)
        self.assertEquals(mapper.HasPtr(ptr), False)
        self.assertEquals(frees, [ptr], "unexpected deallocations")
        self.assertRaises(KeyError, lambda: mapper.PyObject_Free(ptr))

        mapper.Dispose()
        deallocTypes()
示例#2
0
    def test_Py_InitModule4_VarargsKwargsFunction(self):
        mapper = PythonMapper()
        deallocTypes = CreateTypes(mapper)
        args = (object(), object())
        kwargs = {'a': object(), 'b': object()}
        result = object()
        resultPtr = mapper.Store(result)
        mapper.IncRef(resultPtr)

        def func(_, argsPtr, kwargsPtr):
            self.assertEquals(_, MODULE_PTR)
            self.assertEquals(mapper.Retrieve(argsPtr), args)
            self.assertEquals(mapper.Retrieve(kwargsPtr), kwargs)
            return resultPtr

        method, deallocMethod = MakeMethodDef("func", func,
                                              METH.VARARGS | METH.KEYWORDS)

        def testModule(module, mapper):
            self.assertEquals(module.func(*args, **kwargs), result,
                              "not hooked up")

        self.assert_Py_InitModule4_withSingleMethod(mapper, method, testModule)
        deallocMethod()
        deallocTypes()
示例#3
0
 def testNullPointers(self):
     allocator = GetDoNothingTestAllocator([])
     mapper = PythonMapper(allocator)
     self.assertEquals(mapper.HasPtr(IntPtr.Zero), False)
     self.assertRaisesClr(CannotInterpretException, lambda: mapper.IncRef(IntPtr.Zero))
     self.assertRaisesClr(CannotInterpretException, lambda: mapper.DecRef(IntPtr.Zero))
     self.assertRaisesClr(CannotInterpretException, lambda: mapper.Retrieve(IntPtr.Zero))
     self.assertRaisesClr(CannotInterpretException, lambda: mapper.RefCount(IntPtr.Zero))
     mapper.Dispose()
示例#4
0
 def test_Py_InitModule4_NoArgsFunction(self):
     mapper = PythonMapper()
     deallocTypes = CreateTypes(mapper)
     result = object()
     resultPtr = mapper.Store(result)
     mapper.IncRef(resultPtr)
     
     def func(_, __):
         self.assertEquals((_, __), (MODULE_PTR, IntPtr.Zero))
         return resultPtr
     method, deallocMethod = MakeMethodDef("func", func, METH.NOARGS)
     
     def testModule(module, mapper):
         self.assertEquals(module.func(), result, "not hooked up")
         
     self.assert_Py_InitModule4_withSingleMethod(mapper, method, testModule)
     deallocMethod()
     deallocTypes()
示例#5
0
 def test_Py_InitModule4_OldargsFunction_OneArg(self):
     mapper = PythonMapper()
     deallocTypes = CreateTypes(mapper)
     arg = object()
     result = object()
     resultPtr = mapper.Store(result)
     mapper.IncRef(resultPtr)
     
     def func(_, argPtr):
         self.assertEquals(_, MODULE_PTR)
         self.assertEquals(mapper.Retrieve(argPtr), arg)
         return resultPtr
     method, deallocMethod = MakeMethodDef("func", func, METH.OLDARGS)
     
     def testModule(module, mapper):
         self.assertEquals(module.func(arg), result, "not hooked up")
         
     self.assert_Py_InitModule4_withSingleMethod(mapper, method, testModule)
     deallocMethod()
     deallocTypes()
示例#6
0
    def testFinalDecRefComplainsAboutMissing_tp_dealloc(self):
        frees = []
        mapper = PythonMapper(GetAllocatingTestAllocator([], frees))
        deallocTypes = CreateTypes(mapper)

        typePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject()))
        CPyMarshal.WritePtrField(typePtr, PyTypeObject, "tp_dealloc", IntPtr.Zero)

        obj = object()
        objPtr = mapper.Store(obj)
        CPyMarshal.WritePtrField(objPtr, PyObject, "ob_type", typePtr)

        mapper.IncRef(objPtr)

        del frees [:]
        mapper.DecRef(objPtr)
        self.assertEquals(frees, [], "freed prematurely")
        self.assertRaisesClr(CannotInterpretException, mapper.DecRef, objPtr)

        mapper.Dispose()
        deallocTypes()