def testWritePtr(self): data = Marshal.AllocHGlobal(CPyMarshal.PtrSize) CPyMarshal.WritePtr(data, IntPtr(0)) self.assertEquals(Marshal.ReadIntPtr(data), IntPtr(0), "wrong") CPyMarshal.WritePtr(data, IntPtr(100001)) self.assertEquals(Marshal.ReadIntPtr(data), IntPtr(100001), "wrong") Marshal.FreeHGlobal(data)
def testInternExisting(self, mapper, addToCleanUp): testString = "mars needs women" + self.getStringWithValues(1, 256) bytes = self.byteArrayFromString(testString) testData = self.ptrFromByteArray(bytes) sp1 = mapper.PyString_FromString(testData) addToCleanUp(lambda: Marshal.FreeHGlobal(sp1p)) sp2 = mapper.PyString_InternFromString(testData) addToCleanUp(lambda: Marshal.FreeHGlobal(testData)) self.assertNotEquals(sp1, sp2) self.assertFalse(mapper.Retrieve(sp1) is mapper.Retrieve(sp2)) self.assertEquals(mapper.RefCount(sp1), 1) self.assertEquals( mapper.RefCount(sp2), 2, 'failed to grab extra reference to induce immortality') mapper.IncRef(sp1) sp1p = Marshal.AllocHGlobal(Marshal.SizeOf(IntPtr)) CPyMarshal.WritePtr(sp1p, sp1) mapper.PyString_InternInPlace(sp1p) sp1i = CPyMarshal.ReadPtr(sp1p) self.assertEquals(sp1i, sp2, 'failed to intern') self.assertTrue(mapper.Retrieve(sp1i) is mapper.Retrieve(sp2)) self.assertEquals(mapper.RefCount(sp1), 1, 'failed to decref old string') self.assertEquals(mapper.RefCount(sp2), 3, 'failed to incref interned string')
def assertPyTuple_New_Works(self, length): allocs = [] mapper = PythonMapper(GetAllocatingTestAllocator(allocs, [])) typeBlock = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject)) mapper.RegisterData("PyTuple_Type", typeBlock) tuplePtr = mapper.PyTuple_New(length) expectedSize = Marshal.SizeOf(PyTupleObject) + (CPyMarshal.PtrSize * (length - 1)) self.assertEquals(allocs, [(tuplePtr, expectedSize)], "bad alloc") tupleStruct = Marshal.PtrToStructure(tuplePtr, PyTupleObject) self.assertEquals(tupleStruct.ob_refcnt, 1, "bad refcount") self.assertEquals(tupleStruct.ob_type, mapper.PyTuple_Type, "bad type") self.assertEquals(tupleStruct.ob_size, length, "bad size") self.assertEquals(mapper.PyTuple_Size(tuplePtr), length, "should still work with uninitialised tuple imo") dataPtr = OffsetPtr(tuplePtr, Marshal.OffsetOf(PyTupleObject, "ob_item")) itemPtrs = [] for i in range(length): self.assertEquals(CPyMarshal.ReadPtr(dataPtr), IntPtr.Zero, "item memory not zeroed") itemPtr = mapper.Store(i + 100) CPyMarshal.WritePtr(dataPtr, itemPtr) itemPtrs.append(itemPtr) dataPtr = OffsetPtr(dataPtr, CPyMarshal.PtrSize) immutableTuple = mapper.Retrieve(tuplePtr) self.assertEquals(immutableTuple, tuple(i + 100 for i in range(length)), "broken") tuplePtr2 = mapper.Store(immutableTuple) self.assertEquals(tuplePtr2, tuplePtr, "didn't realise already had this object stored") self.assertEquals(mapper.RefCount(tuplePtr), 2, "didn't incref") mapper.Dispose() Marshal.FreeHGlobal(typeBlock)
def test_PyTuple_Resize_TooBig(self, mapper, addDealloc): tuplePtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize) addDealloc(lambda: Marshal.FreeHGlobal(tuplePtrPtr)) tuplePtr = mapper.PyTuple_New(1) CPyMarshal.WritePtr(tuplePtrPtr, tuplePtr) self.assertEquals(mapper._PyTuple_Resize(tuplePtrPtr, 2000000000), -1) self.assertEquals(CPyMarshal.ReadPtr(tuplePtrPtr), IntPtr.Zero)
def CreateInstance(mapper, calls): tuplePtr = mapper.PyTuple_New(len(model)) dataPtr = OffsetPtr(tuplePtr, Marshal.OffsetOf(PyTupleObject, "ob_item")) for i in range(len(model)): itemPtr = mapper.Store(model[i]) itemPtrs.append(itemPtr) CPyMarshal.WritePtr(dataPtr, itemPtr) dataPtr = OffsetPtr(dataPtr, CPyMarshal.PtrSize) return tuplePtr
def testFinalDecRefOfObjectWithTypeCalls_tp_dealloc(self, mapper, _): calls = [] def TypeDealloc(ptr): calls.append(ptr) deallocDgt = dgt_void_ptr(TypeDealloc) deallocFP = Marshal.GetFunctionPointerForDelegate(deallocDgt) typePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject())) deallocPtr = CPyMarshal.Offset(typePtr, Marshal.OffsetOf(PyTypeObject, "tp_dealloc")) CPyMarshal.WritePtr(deallocPtr, deallocFP) obj = object() objPtr = mapper.Store(obj) CPyMarshal.WritePtrField(objPtr, PyObject, "ob_type", typePtr) mapper.IncRef(objPtr) mapper.DecRef(objPtr) self.assertEquals(calls, [], "called prematurely") mapper.DecRef(objPtr) self.assertEquals(calls, [objPtr], "not called when refcount hit 0")
def test_PyTuple_Resize(self): allocs = [] mapper = PythonMapper(GetAllocatingTestAllocator(allocs, [])) tuplePtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize) oldTuplePtr = mapper.PyTuple_New(1) del allocs[:] CPyMarshal.WritePtr(tuplePtrPtr, oldTuplePtr) self.assertEquals(mapper._PyTuple_Resize(tuplePtrPtr, 100), 0) newTuplePtr = CPyMarshal.ReadPtr(tuplePtrPtr) expectedSize = Marshal.SizeOf(PyTupleObject) + (CPyMarshal.PtrSize * (99)) self.assertEquals(allocs, [(newTuplePtr, expectedSize)]) tupleStruct = Marshal.PtrToStructure(newTuplePtr, PyTupleObject) self.assertEquals(tupleStruct.ob_refcnt, 1) self.assertEquals(tupleStruct.ob_type, mapper.PyTuple_Type) self.assertEquals(tupleStruct.ob_size, 100) mapper.Dispose() Marshal.FreeHGlobal(tuplePtrPtr)