def testCanChangeValuesDuringIteration(self, mapper, addDealloc):
posPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 3)
keyPtrPtr = CPyMarshal.Offset(posPtr, CPyMarshal.PtrSize)
valuePtrPtr = CPyMarshal.Offset(keyPtrPtr, CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(posPtr))
CPyMarshal.WriteInt(posPtr, 0)
d = dict(a=1, b=2, c=3)
dPtr = mapper.Store(d)
while mapper.PyDict_Next(dPtr, posPtr, keyPtrPtr, valuePtrPtr) != 0:
key = mapper.Retrieve(CPyMarshal.ReadPtr(keyPtrPtr))
value = mapper.Retrieve(CPyMarshal.ReadPtr(valuePtrPtr))
d[key] = value * 10
self.assertEquals(d, dict(a=10, b=20, c=30))
def testIteratesSuccessfully(self, mapper, addDealloc):
posPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 3)
keyPtrPtr = CPyMarshal.Offset(posPtr, CPyMarshal.PtrSize)
valuePtrPtr = CPyMarshal.Offset(keyPtrPtr, CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(posPtr))
CPyMarshal.WriteInt(posPtr, 0)
d = dict(a=1, b=2, c=3)
dPtr = mapper.Store(d)
result = {}
while mapper.PyDict_Next(dPtr, posPtr, keyPtrPtr, valuePtrPtr) != 0:
key = mapper.Retrieve(CPyMarshal.ReadPtr(keyPtrPtr))
value = mapper.Retrieve(CPyMarshal.ReadPtr(valuePtrPtr))
result[key] = value
self.assertEquals(result, d)
def testWorksWithNonString(self, mapper, addDealloc):
dataPtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 2)
sizePtr = CPyMarshal.Offset(dataPtrPtr, CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(dataPtrPtr))
self.assertEquals(
mapper.PyString_AsStringAndSize(mapper.Store(object()), dataPtrPtr,
sizePtr), -1)
self.assertMapperHasError(mapper, TypeError)
def testWorks(self, mapper, _):
strPtr = mapper.Store(
"You're fighting a business hippy. This is a hippy that understands the law of supply and demand."
)
strData = CPyMarshal.Offset(
strPtr, Marshal.OffsetOf(PyStringObject, 'ob_sval'))
self.assertEquals(mapper.PyString_AsString(strPtr),
self.dataPtrFromStrPtr(strPtr))
notstrPtr = mapper.Store(object())
self.assertEquals(mapper.PyString_AsString(notstrPtr), IntPtr.Zero)
self.assertMapperHasError(mapper, TypeError)
def testReferencesAreBorrowed(self, mapper, addDealloc):
posPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 3)
keyPtrPtr = CPyMarshal.Offset(posPtr, CPyMarshal.PtrSize)
valuePtrPtr = CPyMarshal.Offset(keyPtrPtr, CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(posPtr))
CPyMarshal.WriteInt(posPtr, 0)
d = dict(a=1)
dPtr = mapper.Store(d)
mapper.EnsureGIL()
mapper.PyDict_Next(dPtr, posPtr, keyPtrPtr, valuePtrPtr)
keyPtr = CPyMarshal.ReadPtr(keyPtrPtr)
valuePtr = CPyMarshal.ReadPtr(valuePtrPtr)
# grab extra references to retard spoilage
mapper.IncRef(keyPtr)
mapper.IncRef(valuePtr)
mapper.ReleaseGIL()
# check refcount has dropped back to 1
self.assertEquals(mapper.RefCount(keyPtr), 1)
self.assertEquals(mapper.RefCount(valuePtr), 1)
def testOffset(self):
self.assertEquals(CPyMarshal.Offset(IntPtr(354), 123), IntPtr(477))
self.assertEquals(CPyMarshal.Offset(IntPtr(354), 0), IntPtr(354))
self.assertEquals(CPyMarshal.Offset(IntPtr(354), -123), IntPtr(231))
self.assertEquals(CPyMarshal.Offset(IntPtr(354), UInt32(123)),
IntPtr(477))
self.assertEquals(CPyMarshal.Offset(IntPtr(354), IntPtr(123)),
IntPtr(477))
self.assertEquals(CPyMarshal.Offset(IntPtr(354), IntPtr(0)),
IntPtr(354))
def testDoesNotActualiseString(self, mapper, addDealloc):
dataPtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 2)
sizePtr = CPyMarshal.Offset(dataPtrPtr, CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(dataPtrPtr))
testString = "You find a frozen Mob Penguin."
strPtr = mapper.PyString_FromStringAndSize(IntPtr.Zero,
len(testString))
self.fillStringDataWithBytes(
strPtr, self.byteArrayFromString("blah blah nonsense"))
mapper.PyString_AsStringAndSize(
strPtr, dataPtrPtr,
sizePtr) # this should NOT bake the string data
self.fillStringDataWithBytes(strPtr,
self.byteArrayFromString(testString))
self.assertEquals(mapper.Retrieve(strPtr), testString)
def testWorksWithEmbeddedNulls(self, mapper, addDealloc):
dataPtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 2)
sizePtr = CPyMarshal.Offset(dataPtrPtr, CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(dataPtrPtr))
testStr = "You're fighting a saber-toothed ferret." + self.getStringWithValues(
0, 256)
strPtr = mapper.Store(testStr)
dataPtr = self.dataPtrFromStrPtr(strPtr)
self.assertEquals(
mapper.PyString_AsStringAndSize(strPtr, dataPtrPtr, sizePtr), 0)
self.assertEquals(CPyMarshal.ReadPtr(dataPtrPtr), dataPtr)
self.assertEquals(CPyMarshal.ReadInt(sizePtr), len(testStr))
self.assertMapperHasError(mapper, None)
self.assertEquals(
mapper.PyString_AsStringAndSize(strPtr, dataPtrPtr, IntPtr.Zero),
-1)
self.assertMapperHasError(mapper, TypeError)
def testPySequence_SetItem_List(self, mapper, _):
seq = [1, 2, 3]
seqPtr = mapper.Store(seq)
seqData = CPyMarshal.ReadPtrField(seqPtr, PyListObject, "ob_item")
for i in range(3):
itemPtr = mapper.Store(i)
self.assertEquals(mapper.PySequence_SetItem(seqPtr, i, itemPtr), 0)
self.assertEquals(mapper.RefCount(itemPtr), 2)
index = i
if index < 0:
index += 3
valData = CPyMarshal.Offset(seqData, index * CPyMarshal.PtrSize)
self.assertEquals(CPyMarshal.ReadPtr(valData), itemPtr)
self.assertEquals(seq[i], i)
for i in (5, 66):
mapper.LastException = None
self.assertEquals(mapper.PySequence_SetItem(seqPtr, i, mapper.Store(i)), -1)
self.assertMapperHasError(mapper, IndexError)
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")
