import sys
import unittest
import pywintypes
import win32api
from pywin32_testutil import int2long

# A class that will never die vie refcounting, but will die via GC.
class Cycle:
    def __init__(self, handle):
        self.cycle = self
        self.handle = handle

class PyHandleTestCase(unittest.TestCase):
    def testCleanup1(self):
        # We used to clobber all outstanding exceptions.
        def f1(invalidate):
            import win32event
            h = win32event.CreateEvent(None, 0, 0, None)
            if invalidate:
                win32api.CloseHandle(int(h))
            1/0
            # If we invalidated, then the object destruction code will attempt 
            # to close an invalid handle.  We don't wan't an exception in 
            # this case

        def f2(invalidate):
            """ This function should throw an IOError. """
            try:
                f1(invalidate)
            except ZeroDivisionError, exc:
                raise IOError("raise 2")

        self.assertRaises(IOError, f2, False)
        # Now do it again, but so the auto object destruction
        # actually fails.
        self.assertRaises(IOError, f2, True)

    def testCleanup2(self):
        # Cause an exception during object destruction.
        # The worst this does is cause an ".XXX undetected error (why=3)" 
        # So avoiding that is the goal
        import win32event
        h = win32event.CreateEvent(None, 0, 0, None)
        # Close the handle underneath the object.
        win32api.CloseHandle(int(h))
        # Object destructor runs with the implicit close failing
        h = None

    def testCleanup3(self):
        # And again with a class - no __del__
        import win32event
        class Test:
            def __init__(self):
                self.h = win32event.CreateEvent(None, 0, 0, None)
                win32api.CloseHandle(int(self.h))
        t=Test()
        t = None

    def testCleanupGood(self):
        # And check that normal error semantics *do* work.
        import win32event
        h = win32event.CreateEvent(None, 0, 0, None)
        win32api.CloseHandle(int(h))
        self.assertRaises(win32api.error, h.Close)
        # A following Close is documented as working
        h.Close()

    def testInvalid(self):
        h=pywintypes.HANDLE(-2)
        self.assertRaises(win32api.error, h.Close)

    def testOtherHandle(self):
        h=pywintypes.HANDLE(1)
        h2=pywintypes.HANDLE(h)
        self.failUnlessEqual(h, h2)
        # but the above doesn't really test everything - we want a way to
        # pass the handle directly into PyWinLong_AsVoidPtr.  One way to
        # to that is to abuse win32api.GetProcAddress() - the 2nd param
        # is passed to PyWinLong_AsVoidPtr() if its not a string.
        # passing a handle value of '1' should work - there is something
        # at that ordinal
        win32api.GetProcAddress(sys.dllhandle, h)

    def testHandleInDict(self):
        h=pywintypes.HANDLE(1)
        d = dict(foo=h)
        self.failUnlessEqual(d['foo'], h)

    def testHandleInDictThenInt(self):
        h=pywintypes.HANDLE(1)
        d = dict(foo=h)
        self.failUnlessEqual(d['foo'], 1)

    def testHandleCompareNone(self):
        h=pywintypes.HANDLE(1)
        self.failIfEqual(h, None)
        self.failIfEqual(None, h)
        # ensure we use both __eq__ and __ne__ ops
        self.failIf(h==None)
        self.failUnless(h!=None)

    def testHandleCompareInt(self):
        h=pywintypes.HANDLE(1)
        self.failIfEqual(h, 0)
        self.failUnlessEqual(h, 1)
        # ensure we use both __eq__ and __ne__ ops
        self.failUnless(h==1)
        self.failUnless(1==h)
        self.failIf(h!=1)
        self.failIf(1!=h)
        self.failIf(h==0)
        self.failIf(0==h)
        self.failUnless(h!=0)
        self.failUnless(0!=h)

    def testHandleNonZero(self):
        h=pywintypes.HANDLE(0)
        self.failIf(h)

        h=pywintypes.HANDLE(1)
        self.failUnless(h)

    def testLong(self):
        # sys.maxint+1 should always be a 'valid' handle, treated as an
        # unsigned int, even though it is a long. Although pywin32 should not
        # directly create such longs, using struct.unpack() with a P format
        # may well return them. eg:
        # >>> struct.unpack("P", struct.pack("P", -1))
        # (4294967295L,)
        try:
            big = sys.maxsize
        except AttributeError:
            big = sys.maxint
        pywintypes.HANDLE(big+1)

    def testGC(self):
        # This used to provoke:
        # Fatal Python error: unexpected exception during garbage collection
        def make():
            h=pywintypes.HANDLE(-2)
            c = Cycle(h)
        import gc
        make()
        gc.collect()

    def testTypes(self):
        self.assertRaises(TypeError, pywintypes.HANDLE, "foo")
        self.assertRaises(TypeError, pywintypes.HANDLE, ())
        # should be able to get a long!
        pywintypes.HANDLE(int2long(0))

if __name__ == '__main__':
    unittest.main()