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)
