def test_mem(self):
     val = str2bytes("test")
     expected = str2bytes("test\0")
     SetClipboardData(win32con.CF_TEXT, val)
     # Get the raw data - this will include the '\0'
     raw_data = GetGlobalMemory(GetClipboardDataHandle(win32con.CF_TEXT))
     self.failUnlessEqual(expected, raw_data)

 def testAcceptEx(self):
     port = 4680
     running = threading.Event()
     stopped = threading.Event()
     t = threading.Thread(target=self.acceptWorker, args=(port, running,stopped))
     t.start()
     running.wait(2)
     if not running.isSet():
         self.fail("AcceptEx Worker thread failed to start")
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     s.connect(('127.0.0.1', port))
     win32file.WSASend(s, str2bytes("hello"), None)
     overlapped = pywintypes.OVERLAPPED()
     overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
     # Like above - WSARecv used to allow strings as the receive buffer!!
     buffer = " " * 10
     self.assertRaises(TypeError, win32file.WSARecv, s, buffer, overlapped)
     # This one should work :)
     buffer = win32file.AllocateReadBuffer(10)
     win32file.WSARecv(s, buffer, overlapped)
     nbytes = win32file.GetOverlappedResult(s.fileno(), overlapped, True)
     got = buffer[:nbytes]
     self.failUnlessEqual(got, str2bytes("hello"))
     # thread should have stopped
     stopped.wait(2)
     if not stopped.isSet():
         self.fail("AcceptEx Worker thread failed to successfully stop")

    def _doTestSign(self, pkg_name):

        sspiclient, sspiserver = self._doAuth(pkg_name)

        pkg_size_info=sspiclient.ctxt.QueryContextAttributes(sspicon.SECPKG_ATTR_SIZES)
        msg=str2bytes('some data to be encrypted ......')
        
        sigsize=pkg_size_info['MaxSignature']
        sigbuf=win32security.PySecBufferDescType()
        sigbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA))
        sigbuf.append(win32security.PySecBufferType(sigsize, sspicon.SECBUFFER_TOKEN))
        sigbuf[0].Buffer=msg
        sspiclient.ctxt.MakeSignature(0,sigbuf,0)
        sspiserver.ctxt.VerifySignature(sigbuf,0)
        # and test the higher-level functions
        sspiclient.next_seq_num = 1
        sspiserver.next_seq_num = 1
        data = str2bytes("hello")
        key = sspiclient.sign(data)
        sspiserver.verify(data, key)
        key = sspiclient.sign(data)
        self.assertRaisesHRESULT(sspicon.SEC_E_MESSAGE_ALTERED,
                                 sspiserver.verify, data + data, key)

        # and the other way
        key = sspiserver.sign(data)
        sspiclient.verify(data, key)
        key = sspiserver.sign(data)
        self.assertRaisesHRESULT(sspicon.SEC_E_MESSAGE_ALTERED,
                                 sspiclient.verify, data + data, key)

 def test_connect_with_payload(self):
     giveup_event = win32event.CreateEvent(None, 0, 0, None)
     t = threading.Thread(target=self.connect_thread_runner,
                          args=(True, giveup_event))
     t.start()
     time.sleep(0.1)
     s2 = socket.socket()
     ol = pywintypes.OVERLAPPED()
     s2.bind(('0.0.0.0', 0)) # connectex requires the socket be bound beforehand
     try:
         win32file.ConnectEx(s2, self.addr, ol, str2bytes("some expected request"))
     except win32file.error as exc:
         win32event.SetEvent(giveup_event)
         if exc.winerror == 10022: # WSAEINVAL
             raise TestSkipped("ConnectEx is not available on this platform")
         raise # some error error we don't expect.
     win32file.GetOverlappedResult(s2.fileno(), ol, 1)
     ol = pywintypes.OVERLAPPED()
     buff = win32file.AllocateReadBuffer(1024)
     win32file.WSARecv(s2, buff, ol, 0)
     length = win32file.GetOverlappedResult(s2.fileno(), ol, 1)
     self.response = buff[:length]
     self.assertEqual(self.response, str2bytes('some expected response'))
     self.assertEqual(self.request, str2bytes('some expected request'))
     t.join(5)
     self.failIf(t.isAlive(), "worker thread didn't terminate")

 def test_memory_slice(self):
     # Check we can slice the buffer object returned by PyGetMemory
     test_data = pywin32_testutil.str2bytes("\0\1\2\3\4\5\6")
     c = array.array("b", test_data)
     addr, buflen = c.buffer_info()
     got = win32gui.PyGetMemory(addr, buflen)
     self.failUnlessEqual(got[0:3], pywin32_testutil.str2bytes('\0\1\2'))

    def testTransactNamedPipeAsync(self):
        event = threading.Event()
        overlapped = pywintypes.OVERLAPPED()
        overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
        self.startPipeServer(event, 0.5)
        open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE

        hpipe = win32file.CreateFile(self.pipename,
                                     open_mode,
                                     0, # no sharing
                                     None, # default security
                                     win32con.OPEN_EXISTING,
                                     win32con.FILE_FLAG_OVERLAPPED,
                                     None)

        # set to message mode.
        win32pipe.SetNamedPipeHandleState(
                        hpipe, win32pipe.PIPE_READMODE_MESSAGE, None, None)

        buffer = win32file.AllocateReadBuffer(1024)
        hr, got = win32pipe.TransactNamedPipe(hpipe, str2bytes("foo\0bar"), buffer, overlapped)
        self.failUnlessEqual(hr, winerror.ERROR_IO_PENDING)
        nbytes = win32file.GetOverlappedResult(hpipe, overlapped, True)
        got = buffer[:nbytes]
        self.failUnlessEqual(got, str2bytes("bar\0foo"))
        event.wait(5)
        self.failUnless(event.isSet(), "Pipe server thread didn't terminate")

    def testit(self):
        mydata = str2bytes('abcdefghijklmnopqrstuvwxyz')
    
        # First test the objects just as Python objects...
        s = Stream(mydata)
        p = Persists()
    
        p.Load(s)
        p.Save(s, 0)
        self.assertEqual(s.data, mydata)

        # Wrap the Python objects as COM objects, and make the calls as if
        # they were non-Python COM objects.
        s2 = win32com.server.util.wrap(s, pythoncom.IID_IStream)
        p2 = win32com.server.util.wrap(p, pythoncom.IID_IPersistStreamInit)

        self._readWrite(mydata, s, s)
        self._readWrite(mydata, s, s2)
        self._readWrite(mydata, s2, s)
        self._readWrite(mydata, s2, s2)

        self._readWrite(str2bytes("string with\0a NULL"), s2, s2)
        # reset the stream
        s.Write(mydata)
        p2.Load(s2)
        p2.Save(s2, 0)
        self.assertEqual(s.data, mydata)

 def test_memory_not_writable(self):
     # Check the buffer object fetched by PyGetMemory isn't writable.
     test_data = pywin32_testutil.str2bytes("\0\1\2\3\4\5\6")
     c = array.array("b", test_data)
     addr, buflen = c.buffer_info()
     got = win32gui.PyGetMemory(addr, buflen)
     new = pywin32_testutil.str2bytes('\1')
     self.failUnlessRaises(TypeError, operator.setitem, got, 0, new)

    def testCallNamedPipe(self):
        event = threading.Event()
        self.startPipeServer(event)

        got = win32pipe.CallNamedPipe(self.pipename,str2bytes("foo\0bar"), 1024, win32pipe.NMPWAIT_WAIT_FOREVER)
        self.failUnlessEqual(got, str2bytes("bar\0foo"))
        event.wait(5)
        self.failUnless(event.isSet(), "Pipe server thread didn't terminate")

 def _serverThread(self, pipe_handle, event, wait_time):
     # just do one connection and terminate.
     hr = win32pipe.ConnectNamedPipe(pipe_handle)
     self.failUnless(hr in (0, winerror.ERROR_PIPE_CONNECTED), "Got error code 0x%x" % (hr,))
     hr, got = win32file.ReadFile(pipe_handle, 100)
     self.failUnlessEqual(got, str2bytes("foo\0bar"))
     time.sleep(wait_time)
     win32file.WriteFile(pipe_handle, str2bytes("bar\0foo"))
     pipe_handle.Close()
     event.set()

 def testEntropy(self):
     data = str2bytes("My test data")
     entropy = str2bytes("My test entropy")
     desc = "My description"
     flags = 0
     ps = None
     blob = win32crypt.CryptProtectData(data, desc, entropy, None, ps, flags)
     got_desc, got_data = win32crypt.CryptUnprotectData(blob, entropy, None, ps, flags)
     self.failUnlessEqual(data, got_data)
     self.failUnlessEqual(desc, got_desc)

 def test_real_view(self):
     # Do the PyGetMemory, then change the original memory, then ensure
     # the initial object we fetched sees the new value.
     test_data = pywin32_testutil.str2bytes("\0\1\2\3\4\5\6")
     c = array.array("b", test_data)
     addr, buflen = c.buffer_info()
     got = win32gui.PyGetMemory(addr, buflen)
     self.failUnlessEqual(got[0], pywin32_testutil.str2bytes('\0'))
     new = pywin32_testutil.str2bytes('\1')
     c[0] = 1
     self.failUnlessEqual(got[0], new)

 def testPythonDotOrg(self):
     hdl = InternetOpenUrl(self.hi, "http://www.python.org", None,
                           INTERNET_FLAG_EXISTING_CONNECT)
     chunks = []
     while 1:
         chunk = InternetReadFile(hdl, 1024)
         if not chunk:
             break
         chunks.append(chunk)
     data = str2bytes('').join(chunks)
     assert data.find(str2bytes("Python"))>0, repr(data) # This must appear somewhere on the main page!

def TestText():
    OpenClipboard()
    try:
        text = "Hello from Python"
        text_bytes = str2bytes(text)
        SetClipboardText(text)
        got = GetClipboardData(win32con.CF_TEXT)
        # CF_TEXT always gives us 'bytes' back .
        assert  got == text_bytes, "Didnt get the correct result back - '%r'." % (got,)
    finally:
        CloseClipboard()

    OpenClipboard()
    try:
        # CF_UNICODE text always gives unicode objects back.
        got = GetClipboardData(win32con.CF_UNICODETEXT)
        assert  got == text, "Didnt get the correct result back - '%r'." % (got,)
        assert type(got)==str, "Didnt get the correct result back - '%r'." % (got,)

        # CF_OEMTEXT is a bytes-based format.
        got = GetClipboardData(win32con.CF_OEMTEXT)
        assert  got == text_bytes, "Didnt get the correct result back - '%r'." % (got,)

        # Unicode tests
        EmptyClipboard()
        text = "Hello from Python unicode"
        text_bytes = str2bytes(text)
        # Now set the Unicode value
        SetClipboardData(win32con.CF_UNICODETEXT, text)
        # Get it in Unicode.
        got = GetClipboardData(win32con.CF_UNICODETEXT)
        assert  got == text, "Didnt get the correct result back - '%r'." % (got,)
        assert type(got)==str, "Didnt get the correct result back - '%r'." % (got,)

        # Close and open the clipboard to ensure auto-conversions take place.
    finally:
        CloseClipboard()

    OpenClipboard()
    try:

        # Make sure I can still get the text as bytes
        got = GetClipboardData(win32con.CF_TEXT)
        assert  got == text_bytes, "Didnt get the correct result back - '%r'." % (got,)
        # Make sure we get back the correct types.
        got = GetClipboardData(win32con.CF_UNICODETEXT)
        assert type(got)==str, "Didnt get the correct result back - '%r'." % (got,)
        got = GetClipboardData(win32con.CF_OEMTEXT)
        assert  got == text_bytes, "Didnt get the correct result back - '%r'." % (got,)
        print("Clipboard text tests worked correctly")
    finally:
        CloseClipboard()

 def testWin32ToCom(self):
     # Set the data via the std win32 clipboard functions.
     val = str2bytes("Hello again!") # ensure always bytes, even in py3k
     win32clipboard.OpenClipboard()
     win32clipboard.SetClipboardData(win32con.CF_TEXT, val)
     win32clipboard.CloseClipboard()
     # and get it via an IDataObject provided by COM
     do = pythoncom.OleGetClipboard()
     cf = win32con.CF_TEXT, None, pythoncom.DVASPECT_CONTENT, -1, pythoncom.TYMED_HGLOBAL
     stg = do.GetData(cf)
     got = stg.data
     # The data we get back has the \0, as our STGMEDIUM has no way of 
     # knowing if it meant to be a string, or a binary buffer, so
     # it must return it too.
     self.failUnlessEqual(got, str2bytes("Hello again!\0"))

 def testSimpleOverlapped(self):
     # Create a file in the %TEMP% directory.
     import win32event
     testName = os.path.join( win32api.GetTempPath(), "win32filetest.dat" )
     desiredAccess = win32file.GENERIC_WRITE
     overlapped = pywintypes.OVERLAPPED()
     evt = win32event.CreateEvent(None, 0, 0, None)
     overlapped.hEvent = evt
     # Create the file and write shit-loads of data to it.
     h = win32file.CreateFile( testName, desiredAccess, 0, None, win32file.CREATE_ALWAYS, 0, 0)
     chunk_data = str2bytes("z") * 0x8000
     num_loops = 512
     expected_size = num_loops * len(chunk_data)
     for i in range(num_loops):
         win32file.WriteFile(h, chunk_data, overlapped)
         win32event.WaitForSingleObject(overlapped.hEvent, win32event.INFINITE)
         overlapped.Offset = overlapped.Offset + len(chunk_data)
     h.Close()
     # Now read the data back overlapped
     overlapped = pywintypes.OVERLAPPED()
     evt = win32event.CreateEvent(None, 0, 0, None)
     overlapped.hEvent = evt
     desiredAccess = win32file.GENERIC_READ
     h = win32file.CreateFile( testName, desiredAccess, 0, None, win32file.OPEN_EXISTING, 0, 0)
     buffer = win32file.AllocateReadBuffer(0xFFFF)
     while 1:
         try:
             hr, data = win32file.ReadFile(h, buffer, overlapped)
             win32event.WaitForSingleObject(overlapped.hEvent, win32event.INFINITE)
             overlapped.Offset = overlapped.Offset + len(data)
             if not data is buffer:
                 self.fail("Unexpected result from ReadFile - should be the same buffer we passed it")
         except win32api.error:
             break
     h.Close()

 def testGUID(self):
     s = "{00020400-0000-0000-C000-000000000046}"
     iid = pywintypes.IID(s)
     iid2 = pywintypes.IID(ob2memory(iid), True)
     self.assertEquals(iid, iid2)
     self.assertRaises(ValueError, pywintypes.IID, str2bytes('00'), True) # too short
     self.assertRaises(TypeError, pywintypes.IID, 0, True) # no buffer

 def SetSize(self, size):
     print("Set Size" + str(size))
     if size > len(self.data):
         self.data = self.data +  str2bytes("\000" * (size - len(self.data)))
     else:
         self.data = self.data[0:size]
     return S_OK

 def test_ob(self):
     # Check the PyGetMemory result and a bytes string can be compared
     test_data = pywin32_testutil.str2bytes("\0\1\2\3\4\5\6")
     c = array.array("b", test_data)
     addr, buflen = c.buffer_info()
     got = win32gui.PyGetMemory(addr, buflen)
     self.failUnlessEqual(len(got), len(test_data))
     self.failUnlessEqual(ob2bytes(got), test_data)

    def test_functional(self):
        # This is not really a unit test, but it does exercise the code
        # quite well and can serve as an example of WSAEventSelect and
        # WSAEnumNetworkEvents usage.
        port = socket.socket()
        port.setblocking(0)
        port_event = win32event.CreateEvent(None, 0, 0, None)
        win32file.WSAEventSelect(port, port_event,
                                 win32file.FD_ACCEPT |
                                 win32file.FD_CLOSE)
        port.bind(("127.0.0.1", 0))
        port.listen(10)

        client = socket.socket()
        client.setblocking(0)
        client_event = win32event.CreateEvent(None, 0, 0, None)
        win32file.WSAEventSelect(client, client_event,
                                 win32file.FD_CONNECT |
                                 win32file.FD_READ |
                                 win32file.FD_WRITE |
                                 win32file.FD_CLOSE)
        err = client.connect_ex(port.getsockname())
        self.assertEquals(err, win32file.WSAEWOULDBLOCK)

        res = win32event.WaitForSingleObject(port_event, 1000)
        self.assertEquals(res, win32event.WAIT_OBJECT_0)
        events = win32file.WSAEnumNetworkEvents(port, port_event)
        self.assertEquals(events, {win32file.FD_ACCEPT: 0})

        server, addr = port.accept()
        server.setblocking(0)
        server_event = win32event.CreateEvent(None, 1, 0, None)
        win32file.WSAEventSelect(server, server_event,
                                 win32file.FD_READ |
                                 win32file.FD_WRITE |
                                 win32file.FD_CLOSE)
        res = win32event.WaitForSingleObject(server_event, 1000)
        self.assertEquals(res, win32event.WAIT_OBJECT_0)
        events = win32file.WSAEnumNetworkEvents(server, server_event)
        self.assertEquals(events, {win32file.FD_WRITE: 0})

        res = win32event.WaitForSingleObject(client_event, 1000)
        self.assertEquals(res, win32event.WAIT_OBJECT_0)
        events = win32file.WSAEnumNetworkEvents(client, client_event)
        self.assertEquals(events, {win32file.FD_CONNECT: 0,
                                   win32file.FD_WRITE: 0})
        sent = 0
        data = str2bytes("x") * 16 * 1024
        while sent < 16 * 1024 * 1024:
            try:
                sent += client.send(data)
            except socket.error, e:
                if e.args[0] == win32file.WSAEINTR:
                    continue
                elif e.args[0] in (win32file.WSAEWOULDBLOCK, win32file.WSAENOBUFS):
                    break
                else:
                    raise