result = -1
                self.assertEquals(mapper.PySequence_Contains(mapper.Store(seq), mapper.Store(val)), result)
                self.assertMapperHasError(mapper, error)

    @WithMapper
    def testPySequence_Tuple_withTuple(self, mapper, _):
        tuplePtr = mapper.Store((1, 2, 3))
        self.assertEquals(mapper.PySequence_Tuple(tuplePtr), tuplePtr)
        self.assertEquals(mapper.RefCount(tuplePtr), 2)
        
    
    @WithMapper
    def testPySequence_Tuple_notTuple(self, mapper, _):
        listPtr = mapper.Store([4, 5, 6])
        tuplePtr = mapper.PySequence_Tuple(listPtr)
        self.assertEquals(mapper.Retrieve(tuplePtr), (4, 5, 6))
    
    
    @WithMapper
    def testPySequence_Tuple_notSequence(self, mapper, _):
        self.assertEquals(mapper.PySequence_Tuple(mapper.Store(123)), IntPtr.Zero)
        self.assertMapperHasError(mapper, TypeError)


suite = makesuite(
    SequenceFunctionsTest,
)

if __name__ == '__main__':
    run(suite)

        path = os.path.join(testDir, "test")

        class C(object):
            __str__ = lambda s: "str"
            __repr__ = lambda s: "repr"

        f = open(path, "w")
        try:
            fPtr = mapper.Store(f)
            cPtr = mapper.Store(C())
            self.assertEquals(mapper.IC_PyFile_WriteObject(cPtr, fPtr, 0), 0)
            self.assertEquals(mapper.IC_PyFile_WriteObject(cPtr, fPtr, 1), 0)
            mapper.DecRef(fPtr)
            self.assertEquals(mapper.IC_PyFile_WriteObject(cPtr, mapper.Store(object()), 0), -1)
            self.assertMapperHasError(mapper, TypeError)
        finally:
            f.close()

        f = open(path)
        try:
            result = f.read()
            self.assertEquals(result, "reprstr")
        finally:
            f.close()


suite = makesuite(PyFile_Type_Test, PyFileAPIFunctions)

if __name__ == "__main__":
    run(suite)

        self.assertRaises(KeyError, allocator.Free, ptr3)
        
        
    def testRealloc(self):
        def DoTest(size):
            allocator = HGlobalAllocator()
            ptr1 = allocator.Alloc(REASONABLE_SIZE)
            ptr2 = allocator.Realloc(ptr1, REASONABLE_SIZE * (2 ** size))
            if (ptr1 == ptr2):
                return False
            
            self.assertEquals(allocator.Contains(ptr1), False)
            self.assertEquals(allocator.Contains(ptr2), True)
            self.assertRaises(KeyError, allocator.Free, ptr1)
            allocator.FreeAll()
            self.assertEquals(allocator.Contains(ptr2), False)
            self.assertRaises(KeyError, allocator.Free, ptr2)
            return True
        
        i = 1
        while not DoTest(i):
            i = i + 1
            if i > 5:
                self.fail("failed to convince allocator to reallocate into a new block")
        
    

suite = makesuite(HGlobalAllocatorTest)

if __name__ == '__main__':
    run(suite)

    @WithMapper
    def testPyTuple_GetSlice(self, mapper, _):
        def TestSlice(originalTuplePtr, start, stop):
            newTuplePtr = mapper.PyTuple_GetSlice(originalTuplePtr, start, stop)
            self.assertMapperHasError(mapper, None)
            self.assertEquals(mapper.Retrieve(newTuplePtr), mapper.Retrieve(originalTuplePtr)[start:stop], "bad slice")
            mapper.DecRef(newTuplePtr)
        
        tuplePtr = mapper.Store((0, 1, 2, 3, 4, 5, 6, 7))
        slices = (
            (3, 4), (5, 0), (5, 200), (999, 1000)
        )
        for (start, stop) in slices:
            TestSlice(tuplePtr, start, stop)
            
         
    @WithMapper
    def testPyTuple_GetSlice_error(self, mapper, _):
        self.assertEquals(mapper.PyTuple_GetSlice(mapper.Store(object()), 1, 2), IntPtr.Zero)
        self.assertMapperHasError(mapper, TypeError)



suite = makesuite(
    PyTuple_Type_Test,
    TupleTest,
)

if __name__ == '__main__':
    run(suite)

        stored = PtrToStructure(methPtr, PyMethodObject)
        self.assertEquals(stored.ob_refcnt, 1)
        self.assertEquals(stored.ob_type, mapper.PyMethod_Type)
        self.assertEquals(stored.im_weakreflist, IntPtr.Zero)
        
        attrs = {
            'im_func': 'foo',
            'im_self': 'bar',
            'im_class': 'baz',
        }
        attrPtrs = []
        for (attr, expected) in attrs.items():
            attrPtr = getattr(stored, attr)
            self.assertEquals(mapper.RefCount(attrPtr), 1)
            mapper.IncRef(attrPtr)
            attrPtrs.append(attrPtr)
            value = mapper.Retrieve(attrPtr)
            self.assertEquals(value, expected)
        
        mapper.DecRef(methPtr)
        for attrPtr in attrPtrs:
            self.assertEquals(mapper.RefCount(attrPtr), 1)
            
        



suite = makesuite(MethodTest)
if __name__ == '__main__':
    run(suite)

            map.CheckBridgePtrs(True)
            del obj1
            del obj2
            return map, ref1, ref2
        map, ref1, ref2 = do()
        gcwait()
        
        self.assertEquals(ref1.IsAlive, False, "failed to GC")
        self.assertEquals(ref2.IsAlive, False, "failed to GC")
    
    
    def testMapOverBridgePtrs(self):
        map, ptr1, obj1, _ = self.getVars()
        __, ptr2, obj2, ___ = self.getVars()
        map.BridgeAssociate(ptr1, obj1)
        map.BridgeAssociate(ptr2, obj2)
        
        ptrs = []
        def MapFunc(ptr):
            ptrs.append(ptr)
        map.MapOverBridgePtrs(PtrFunc(MapFunc))
        self.assertEquals(len(ptrs), 2)
        self.assertEquals(set(ptrs), set([ptr1, ptr2]))
        
        

suite = makesuite(InterestingPtrMapTest)
if __name__ == '__main__':
    run(suite)

        
        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)





suite = makesuite(
    DictTest,
    PyDict_Next_Test,
)

if __name__ == '__main__':
    run(suite)

    def testBigInteger(self):
        for cls in (NumberI, NumberL, NumberF):
            result = NumberMaker.MakeBigInteger(cls())
            self.assertEquals(isinstance(result, long), True)
            self.assertEquals(result, NUMBER_VALUE)

        self.assertRaises(TypeError, lambda: NumberMaker.MakeBigInteger(object()))

    def testUnsignedBigInteger(self):
        class NumberNeg(object):
            def __int__(self):
                return -1
        self.assertRaises(TypeError, lambda: NumberMaker.MakeUnsignedBigInteger(NumberNeg()))

        result = NumberMaker.MakeBigInteger(NumberF())
        self.assertEquals(isinstance(result, long), True)
        self.assertEquals(result, NUMBER_VALUE)

    def testFloat(self):
        for cls in (NumberI, NumberL, NumberF):
            result = NumberMaker.MakeFloat(cls())
            self.assertEquals(isinstance(result, float), True)
            self.assertEquals(result, NUMBER_VALUE)

        self.assertRaises(TypeError, lambda: NumberMaker.MakeFloat(object()))



suite = makesuite(NumberMakerTest)
if __name__ == '__main__':
    run(suite)

            mapper.PyEval_RestoreThread(x)              # 10
            signal(); wait()
            
            mapper.PyEval_RestoreThread(pe_token)       # 12
            signal(); wait()
            
            mapper.PyGILState_Release(0)                # 14
            signal(); wait()
            
            self.assertFalse(lock.TryAcquire())         # 16
            signal()
            
        t = Thread(ThreadStart(AnotherThread))
        t.Start()
        OneThread()
        t.Join()
    
        mapper.EnsureGIL()



suite = makesuite(
    PyThread_functions_Test,
    PyThreadExceptionTest,
    PyThreadStateTest,
    PyEvalGILThreadTest,
)

if __name__ == '__main__':
    run(suite)

        self.assertEquals(mapper.Retrieve(resultPtr), NotImplemented, "not mapped properly")



class PythonMapper_Py_OptimizeFlag_Test(TestCase):

    @WithMapper
    def testFills(self, mapper, addToCleanUp):
        # TODO: if we set a lower value, numpy will crash inside arr_add_docstring
        # I consider docstrings to be low-priority-enough that it's OK to fudge this
        # for now. also, fixing it would be hard ;).
        flagPtr = Marshal.AllocHGlobal(Marshal.SizeOf(Int32()))
        addToCleanUp(lambda: Marshal.FreeHGlobal(flagPtr))
        mapper.RegisterData("Py_OptimizeFlag", flagPtr)
        
        self.assertEquals(CPyMarshal.ReadInt(flagPtr), 2)



suite = makesuite(
    PythonMapper_CreateDestroy_Test,
    PythonMapper_References_Test,
    PythonMapper_GetFuncPtr_NonApi_Test,
    PythonMapper_NoneTest,
    PythonMapper_NotImplementedTest,
    PythonMapper_Py_OptimizeFlag_Test,
)

if __name__ == '__main__':
    run(suite)

    def testPyList_GetSlice_error(self, mapper, _):
        self.assertEquals(mapper.PyList_GetSlice(mapper.Store(object()), 1, 2), IntPtr.Zero)
        self.assertMapperHasError(mapper, TypeError)
        
        
    @WithMapper
    def testPyList_GetItem(self, mapper, _):
        listPtr = mapper.Store([1, 2, 3])
        for i in range(3):
            result = mapper.Retrieve(mapper.PyList_GetItem(listPtr, i))
            self.assertEquals(result, i + 1)
        
        notListPtr = mapper.Store(object())
        self.assertEquals(mapper.PyList_GetItem(notListPtr, 0), IntPtr.Zero)
        self.assertMapperHasError(mapper, TypeError)
    
    
    @WithMapper
    def testPyList_AsTuple(self, mapper, _):
        tPtr = mapper.PyList_AsTuple(mapper.Store([1, 2, 3]))
        self.assertEquals(mapper.Retrieve(tPtr), (1, 2, 3))
        
        
suite = makesuite(
    PyList_Type_Test,
    ListFunctionsTest,
)

if __name__ == '__main__':
    run(suite)

    @WithMapper
    def testPyRun_StringFlags_Locals(self, mapper, _):
        globals_ = {"foo": "bar"}
        locals_ = {"baz": "qux"}
        resultPtr = mapper.PyRun_StringFlags(
            "baz = 123\nqux = foo",
            int(EvalToken.Py_file_input),
            mapper.Store(globals_),
            mapper.Store(locals_),
            IntPtr.Zero,
        )
        self.assertEquals(resultPtr, mapper._Py_NoneStruct)
        self.assertEquals(globals_["foo"], "bar")
        self.assertEquals(locals_["baz"], 123)
        self.assertEquals(locals_["qux"], "bar")

    @WithMapper
    def testPyRun_StringFlags_Error(self, mapper, _):
        resultPtr = mapper.PyRun_StringFlags(
            "raise ValueError('amoral')", int(EvalToken.Py_file_input), mapper.Store({}), IntPtr.Zero, IntPtr.Zero
        )
        self.assertEquals(resultPtr, IntPtr.Zero)
        self.assertMapperHasError(mapper, ValueError)


suite = makesuite(ExecTest)

if __name__ == "__main__":
    run(suite)

    def assertFindsType(self, name):
        class MyPM(PythonApi):
            def fillmethod(self, address):
                WritePyTypeObject(address)
        setattr(MyPM, "Register_" + name, getattr(MyPM, "fillmethod"))
        self.assertDataSetterSetsAndRemembers(MyPM, name, Marshal.SizeOf(PyTypeObject), TestWrotePyTypeObject)


    def testFindsTypes(self):
        for _type in TYPES:
            self.assertFindsType(_type)
        

    def testUninitialisedTypesAreNull(self):
        pa = PythonApi()
        for _type in TYPES:
            self.assertEquals(getattr(pa, _type), IntPtr.Zero, "unexpected")


    def testAddressGetterFailsCleanly(self):
        self.assertEquals(PythonApi().GetFuncPtr("_nonsenx%vQ#*7&"), IntPtr.Zero)


suite = makesuite(
    PythonApiTest,
)

if __name__ == '__main__':
    run(suite)

            text = read(dst, '%s.Generated.cs' % name)
            self.assertNotEquals(text.find(expected), -1, "generated: >>>%s<<<" % text)
        
        assertFinds('CodeSnippets', EXPECTED_SNIPPETS)

        shutil.rmtree(src)
        shutil.rmtree(dst)


SNIPPETS_FILES = {
    'FOO.py': 'some random pile of code',
    'BAR.py': 'some random pile of code, with "double" quotes',
}

EXPECTED_SNIPPETS = """
namespace Ironclad
{
    internal class CodeSnippets
    {
        public const string BAR = @"some random pile of code, with ""double"" quotes";

        public const string FOO = @"some random pile of code";
    }
}
"""


suite = makesuite(GenerateCodeSnippetsTest)
if __name__ == '__main__':
    run(suite)

    
    def testPyMem_Free_NonNull(self):
        frees = []
        mapper = PythonMapper(GetAllocatingTestAllocator([], frees))
        
        ptr = mapper.PyMem_Malloc(123)
        mapper.PyMem_Free(ptr)
        self.assertEquals(frees, [ptr], "did not free")
        mapper.Dispose()
    

    def testPyMem_Free_Null(self):
        frees = []
        mapper = PythonMapper(GetAllocatingTestAllocator([], frees))
        
        mapper.PyMem_Free(IntPtr.Zero)
        self.assertEquals(frees, [], "freed inappropriately")
        mapper.Dispose()


suite = makesuite(
    GetMallocTest('PyMem_Malloc'),
    GetMallocTest('PyObject_Malloc'),
    GetReallocTest('PyMem_Malloc', 'PyMem_Realloc'),
    GetReallocTest('PyObject_Malloc', 'PyObject_Realloc'),
    PyMem_Free_Test, # PyObject_Free is a different matter
)

if __name__ == '__main__':
    run(suite)

        for notmapping in notmappings:
            ptr = mapper.Store(notmapping)
            self.assertEquals(mapper.PyMapping_Check(ptr), 0)
            self.assertEquals(mapper.LastException, None)
            mapper.DecRef(ptr)

    
    @WithMapper
    def testPyMapping_GetItemString(self, mapper, _):
        data = {'foo': 'bar'}
        class Mapping(object):
            def __getitem__(self, key):
                return data[key]
        
        mptr = mapper.Store(Mapping())
        fooresult = mapper.PyMapping_GetItemString(mptr, 'foo')
        self.assertEquals(mapper.Retrieve(fooresult), 'bar')
        
        self.assertEquals(mapper.PyMapping_GetItemString(mptr, 'baz'), IntPtr.Zero)
        self.assertMapperHasError(mapper, KeyError)
        
        


suite = makesuite(
    MappingTest,
)

if __name__ == '__main__':
    run(suite)

        public override void
        Register_PyBar_Type(IntPtr ptr)
        {
            CPyMarshal.Zero(ptr, Marshal.SizeOf(typeof(PyTypeObject)));
            CPyMarshal.WriteIntField(ptr, typeof(PyTypeObject), "ob_refcnt", 1);
            this.NumberSetupMethod(ptr);
            CPyMarshal.WritePtrField(ptr, typeof(PyTypeObject), "tp_init", this.GetFuncPtr("SomeOtherInitMethod"));
            string name = (string)Builtin.getattr(this.scratchContext, TypeCache.Bar, "__name__");
            CPyMarshal.WriteCStringField(ptr, typeof(PyTypeObject), "tp_name", name);
            this.map.Associate(ptr, TypeCache.Bar);
        }

        public override void
        Register_PyBaz_Type(IntPtr ptr)
        {
            CPyMarshal.Zero(ptr, Marshal.SizeOf(typeof(PyTypeObject)));
            CPyMarshal.WriteIntField(ptr, typeof(PyTypeObject), "ob_refcnt", 1);

            string name = (string)Builtin.getattr(this.scratchContext, TypeCache.Baz, "__name__");
            CPyMarshal.WriteCStringField(ptr, typeof(PyTypeObject), "tp_name", name);
            this.map.Associate(ptr, TypeCache.Baz);
        }
    }
}
"""


suite = makesuite(GenerateMapperTest)
if __name__ == '__main__':
    run(suite)

        # check that it gets inherited (or not)
        mapper.Retrieve(basePtr)
        mapper.Retrieve(typePtr)
        CPyMarshal.WriteIntField(typePtr, PyTypeObject, "tp_flags", int(Py_TPFLAGS.HAVE_CLASS))
        # end rigmarole
        
        CPyMarshal.WritePtrField(typePtr, PyTypeObject, "tp_base", basePtr)
        for field in INHERIT_FIELDS + DONT_INHERIT_FIELDS:
            CPyMarshal.WritePtrField(typePtr, PyTypeObject, field, NO_VALUE)
            CPyMarshal.WritePtrField(basePtr, PyTypeObject, field, SOME_VALUE)
        
        mapper.PyType_Ready(typePtr)
        for field in INHERIT_FIELDS:
            self.assertEquals(CPyMarshal.ReadPtrField(typePtr, PyTypeObject, field), SOME_VALUE)
        for field in DONT_INHERIT_FIELDS:
            self.assertEquals(CPyMarshal.ReadPtrField(typePtr, PyTypeObject, field), NO_VALUE)
        


suite = makesuite(
    Types_Test,
    OldStyle_Test,
    PyType_GenericNew_Test,
    IC_PyType_New_Test,
    PyType_GenericAlloc_Test,
    PyType_Ready_InheritTest,
)

if __name__ == '__main__':
    run(suite)

            self.assertEquals(_int, int(value), "converted wrong")
            self.assertMapperHasError(mapper, None)
            mapper.DecRef(ptr)
        
        badvalues = ['foo', object, object(), "123.45"]
        for value in badvalues:
            ptr = mapper.Store(value)
            self.assertEquals(mapper.PyNumber_Int(ptr), IntPtr.Zero)
            
            error = None
            try:
                int(value)
            except Exception, e:
                error = type(e)
            self.assertMapperHasError(mapper, error)
            mapper.DecRef(ptr)
        
    

suite = makesuite(
    PyBool_Test,
    PyInt_Test,
    PyLong_Test,
    PyFloat_Test,
    PyComplex_Test,
    PyNumber_Test,
)

if __name__ == '__main__':
    run(suite)

        self.assertEquals(lock.CountAcquired, 0)

    def testMultiThreaded(self):
        lock = Lock()

        def TestCanAcquire():
            self.assertEquals(lock.Acquire(), 1)
            self.assertEquals(lock.IsAcquired, True)
            lock.Release()

        t = Thread(ThreadStart(TestCanAcquire))
        t.Start()
        t.Join()

        lock.Acquire()

        def TestCannotAcquire():
            self.assertEquals(lock.TryAcquire(), False)
            self.assertEquals(lock.IsAcquired, False)

        t = Thread(ThreadStart(TestCannotAcquire))
        t.Start()
        t.Join()

        lock.Release()


suite = makesuite(LockTest)
if __name__ == "__main__":
    run(suite)