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.assertEqual(hr, winerror.ERROR_IO_PENDING) nbytes = win32file.GetOverlappedResult(hpipe, overlapped, True) got = buffer[:nbytes] self.assertEqual(got, str2bytes("bar\0foo")) event.wait(5) self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
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 _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_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)) assert expected == raw_data
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 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 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 testTransactNamedPipeBlockingBuffer(self): # Like testTransactNamedPipeBlocking, but a pre-allocated buffer is # passed (not really that useful, but it exercises the code path) event = threading.Event() self.startPipeServer(event) open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE hpipe = win32file.CreateFile( self.pipename, open_mode, 0, # no sharing None, # default security win32con.OPEN_EXISTING, 0, # 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, None ) self.assertEqual(got, str2bytes("bar\0foo")) event.wait(5) self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
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 test_memory_index(self): # Check we can index into 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], pywin32_testutil.str2bytes('\0'))
def test_mem(self): val = str2bytes("test.py") expected = str2bytes("test.py\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 testit(self): mydata = str2bytes('abcdefghijklmnopqrstuvwxyz') # First test.py 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_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) assert got[0:3] == pywin32_testutil.str2bytes('\0\1\2')
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 _doTestEncrypt(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 ......") trailersize = pkg_size_info["SecurityTrailer"] encbuf = win32security.PySecBufferDescType() encbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA)) encbuf.append( win32security.PySecBufferType(trailersize, sspicon.SECBUFFER_TOKEN) ) encbuf[0].Buffer = msg sspiclient.ctxt.EncryptMessage(0, encbuf, 1) sspiserver.ctxt.DecryptMessage(encbuf, 1) self.failUnlessEqual(msg, encbuf[0].Buffer) # and test the higher-level functions data_in = str2bytes("hello") data, sig = sspiclient.encrypt(data_in) self.assertEqual(sspiserver.decrypt(data, sig), data_in) data, sig = sspiserver.encrypt(data_in) self.assertEqual(sspiclient.decrypt(data, sig), data_in)
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 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 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 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 demo(): """ Definition of buffer used with FSCTL_TXFS_CREATE_MINIVERSION: typedef struct _TXFS_CREATE_MINIVERSION_INFO{ USHORT StructureVersion; USHORT StructureLength; ULONG BaseVersion; USHORT MiniVersion;} """ buf_fmt='HHLH0L' ## buffer size must include struct padding buf_size=struct.calcsize(buf_fmt) tempdir=win32api.GetTempPath() tempfile=win32api.GetTempFileName(tempdir,'cft')[0] print("Demonstrating transactions on tempfile", tempfile) f=open(tempfile,'w') f.write('This is original file.\n') f.close() trans=win32transaction.CreateTransaction(Description='Test creating miniversions of a file') hfile=win32file.CreateFileW(tempfile, win32con.GENERIC_READ|win32con.GENERIC_WRITE, win32con.FILE_SHARE_READ|win32con.FILE_SHARE_WRITE, None, win32con.OPEN_EXISTING, 0 , None, Transaction=trans) win32file.WriteFile(hfile, str2bytes('This is first miniversion.\n')) buf=win32file.DeviceIoControl(hfile, winioctlcon.FSCTL_TXFS_CREATE_MINIVERSION,None,buf_size,None) struct_ver, struct_len, base_ver, ver_1=struct.unpack(buf_fmt, buf) win32file.SetFilePointer(hfile, 0, win32con.FILE_BEGIN) win32file.WriteFile(hfile, str2bytes('This is second miniversion!\n')) buf=win32file.DeviceIoControl(hfile, winioctlcon.FSCTL_TXFS_CREATE_MINIVERSION,None,buf_size,None) struct_ver, struct_len, base_ver, ver_2=struct.unpack(buf_fmt, buf) hfile.Close() ## miniversions can't be opened with write access hfile_0=win32file.CreateFileW(tempfile, win32con.GENERIC_READ, win32con.FILE_SHARE_READ|win32con.FILE_SHARE_WRITE, None, win32con.OPEN_EXISTING, 0 , None, Transaction=trans, MiniVersion=base_ver) print('version:',base_ver,win32file.ReadFile(hfile_0, 100)) hfile_0.Close() hfile_1=win32file.CreateFileW(tempfile, win32con.GENERIC_READ, win32con.FILE_SHARE_READ|win32con.FILE_SHARE_WRITE, None, win32con.OPEN_EXISTING, 0 , None, Transaction=trans, MiniVersion=ver_1) print('version:',ver_1,win32file.ReadFile(hfile_1, 100)) hfile_1.Close() hfile_2=win32file.CreateFileW(tempfile, win32con.GENERIC_READ, win32con.FILE_SHARE_READ|win32con.FILE_SHARE_WRITE, None, win32con.OPEN_EXISTING, 0 , None, Transaction=trans, MiniVersion=ver_2) print('version:',ver_2,win32file.ReadFile(hfile_2, 100)) hfile_2.Close() ## MiniVersions are destroyed when transaction is committed or rolled back win32transaction.CommitTransaction(trans) os.unlink(tempfile)
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.py data") entropy = str2bytes("My test.py 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 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 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 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 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) assert got[0] == pywin32_testutil.str2bytes('\0') new = pywin32_testutil.str2bytes('\1') c[0] = 1 assert got[0] == new
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) assert data == got_data assert desc == got_desc
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 testFilePointer(self): # via [ 979270 ] SetFilePointer fails with negative offset # Create a file in the %TEMP% directory. filename = os.path.join(win32api.GetTempPath(), "win32filetest.dat") f = win32file.CreateFile( filename, win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0, None, win32file.CREATE_ALWAYS, win32file.FILE_ATTRIBUTE_NORMAL, 0) try: #Write some data data = str2bytes('Some data') (res, written) = win32file.WriteFile(f, data) self.failIf(res) self.assertEqual(written, len(data)) #Move at the beginning and read the data win32file.SetFilePointer(f, 0, win32file.FILE_BEGIN) (res, s) = win32file.ReadFile(f, len(data)) self.failIf(res) self.assertEqual(s, data) #Move at the end and read the data win32file.SetFilePointer(f, -len(data), win32file.FILE_END) (res, s) = win32file.ReadFile(f, len(data)) self.failIf(res) self.failUnlessEqual(s, data) finally: f.Close() os.unlink(filename)
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 _doTestEncryptStream(self, pkg_name): # Test out the SSPI/GSSAPI interop wrapping examples at # https://docs.microsoft.com/en-us/windows/win32/secauthn/sspi-kerberos-interoperability-with-gssapi sspiclient, sspiserver = self._doAuth(pkg_name) pkg_size_info = sspiclient.ctxt.QueryContextAttributes( sspicon.SECPKG_ATTR_SIZES ) msg = str2bytes("some data to be encrypted ......") trailersize = pkg_size_info["SecurityTrailer"] blocksize = pkg_size_info["BlockSize"] encbuf = win32security.PySecBufferDescType() encbuf.append( win32security.PySecBufferType(trailersize, sspicon.SECBUFFER_TOKEN) ) encbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA)) encbuf.append( win32security.PySecBufferType(blocksize, sspicon.SECBUFFER_PADDING) ) encbuf[1].Buffer = msg sspiclient.ctxt.EncryptMessage(0, encbuf, 1) encmsg = encbuf[0].Buffer + encbuf[1].Buffer + encbuf[2].Buffer decbuf = win32security.PySecBufferDescType() decbuf.append( win32security.PySecBufferType(len(encmsg), sspicon.SECBUFFER_STREAM) ) decbuf.append(win32security.PySecBufferType(0, sspicon.SECBUFFER_DATA)) decbuf[0].Buffer = encmsg sspiserver.ctxt.DecryptMessage(decbuf, 1) self.failUnlessEqual(msg, decbuf[1].Buffer)
def testSimpleFiles(self): fd, filename = tempfile.mkstemp() os.close(fd) os.unlink(filename) handle = win32file.CreateFile(filename, win32file.GENERIC_WRITE, 0, None, win32con.CREATE_NEW, 0, None) test_data = str2bytes("Hello\0there") try: win32file.WriteFile(handle, test_data) handle.Close() # Try and open for read handle = win32file.CreateFile( filename, win32file.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, 0, None, ) rc, data = win32file.ReadFile(handle, 1024) self.assertEquals(data, test_data) finally: handle.Close() try: os.unlink(filename) except os.error: pass
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 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 testValues(self): key_name = r'PythonTestHarness\win32api' # tuples containing value name, value type, data values = ( (None, win32con.REG_SZ, 'This is default unnamed value'), ('REG_SZ', win32con.REG_SZ, 'REG_SZ text data'), ('REG_EXPAND_SZ', win32con.REG_EXPAND_SZ, '%systemdir%'), # REG_MULTI_SZ value needs to be a list since strings are returned # as a list ('REG_MULTI_SZ', win32con.REG_MULTI_SZ, ['string 1', 'string 2', 'string 3', 'string 4']), ('REG_MULTI_SZ_empty', win32con.REG_MULTI_SZ, []), ('REG_DWORD', win32con.REG_DWORD, 666), ('REG_QWORD', win32con.REG_QWORD, 2**33), ('REG_BINARY', win32con.REG_BINARY, str2bytes('\x00\x01\x02\x03\x04\x05\x06\x07\x08\x01\x00')), ) hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, key_name) for value_name, reg_type, data in values: win32api.RegSetValueEx(hkey, value_name, None, reg_type, data) for value_name, orig_type, orig_data in values: data, typ = win32api.RegQueryValueEx(hkey, value_name) assert typ == orig_type assert data == orig_data
def testValues(self): key_name = r"PythonTestHarness\win32api" ## tuples containing value name, value type, data values = ( (None, win32con.REG_SZ, "This is default unnamed value"), ("REG_SZ", win32con.REG_SZ, "REG_SZ text data"), ("REG_EXPAND_SZ", win32con.REG_EXPAND_SZ, "%systemdir%"), ## REG_MULTI_SZ value needs to be a list since strings are returned as a list ( "REG_MULTI_SZ", win32con.REG_MULTI_SZ, ["string 1", "string 2", "string 3", "string 4"], ), ("REG_MULTI_SZ_empty", win32con.REG_MULTI_SZ, []), ("REG_DWORD", win32con.REG_DWORD, 666), ("REG_QWORD_INT", win32con.REG_QWORD, 99), ("REG_QWORD", win32con.REG_QWORD, 2**33), ( "REG_BINARY", win32con.REG_BINARY, str2bytes("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x01\x00"), ), ) hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, key_name) for value_name, reg_type, data in values: win32api.RegSetValueEx(hkey, value_name, None, reg_type, data) for value_name, orig_type, orig_data in values: data, typ = win32api.RegQueryValueEx(hkey, value_name) self.assertEqual(typ, orig_type) self.assertEqual(data, orig_data)
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_set_zero_length(self): self.assertEqual( self.cur.execute( "insert into %s (userid,username) " "values (?,?)" % self.tablename, [str2bytes('Frank'), '']), 1) self.assertEqual(self.cur.execute("select * from %s" % self.tablename), 0) self.assertEqual(len(self.cur.fetchone()[1]), 0)
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
def test_unicode_text(self): val = "test-val" SetClipboardText(val) # GetClipboardData doesn't to auto string conversions - so on py3k, # CF_TEXT returns bytes. expected = str2bytes(val) self.failUnlessEqual(GetClipboardData(win32con.CF_TEXT), expected) SetClipboardText(val, win32con.CF_UNICODETEXT) self.failUnlessEqual(GetClipboardData(win32con.CF_UNICODETEXT), val)
def test_custom_mem(self): test_data = str2bytes("hello\x00\xff") test_buffer = array.array("b", test_data) cf = RegisterClipboardFormat(custom_format_name) self.failUnlessEqual(custom_format_name, GetClipboardFormatName(cf)) SetClipboardData(cf, test_buffer) hglobal = GetClipboardDataHandle(cf) data = GetGlobalMemory(hglobal) self.failUnlessEqual(data, test_data)
def testPIDL(self): # A PIDL of "\1" is: cb pidl cb expect = str2bytes("\03\00" "\1" "\0\0") self.assertEqual(shell.PIDLAsString([str2bytes("\1")]), expect) self._rtPIDL([str2bytes("\0")]) self._rtPIDL([str2bytes("\1"), str2bytes("\2"), str2bytes("\3")]) self._rtPIDL([str2bytes("\0") * 2048] * 2048) # PIDL must be a list self.assertRaises(TypeError, shell.PIDLAsString, "foo")
def testTransactNamedPipeBlocking(self): event = threading.Event() self.startPipeServer(event) open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE hpipe = win32file.CreateFile(self.pipename, open_mode, 0, # no sharing None, # default security win32con.OPEN_EXISTING, 0, # win32con.FILE_FLAG_OVERLAPPED, None) # set to message mode. win32pipe.SetNamedPipeHandleState( hpipe, win32pipe.PIPE_READMODE_MESSAGE, None, None) hr, got = win32pipe.TransactNamedPipe(hpipe, str2bytes("foo\0bar"), 1024, None) self.failUnlessEqual(got, str2bytes("bar\0foo")) event.wait(5) self.failUnless(event.isSet(), "Pipe server thread didn't terminate")
def setUp(self): import tempfile self.src_name = os.path.join(tempfile.gettempdir(), "pywin32_testshell") self.dest_name = os.path.join(tempfile.gettempdir(), "pywin32_testshell_dest") self.test_data = str2bytes("Hello from\0Python") f=open(self.src_name, "wb") f.write(self.test_data) f.close() try: os.unlink(self.dest_name) except os.error: pass
def wav_header_unpack(data): (riff, riffsize, wave, fmt, fmtsize, format, nchannels, samplespersecond, datarate, blockalign, bitspersample, data, datalength) \ = struct.unpack('<4sl4s4slhhllhh4sl', data) if riff != str2bytes('RIFF'): raise ValueError('invalid wav header') if fmtsize != 16 or fmt != str2bytes('fmt ') or str2bytes(data) != 'data': # fmt chuck is not first chunk, directly followed by data chuck # It is nowhere required that they are, it is just very common raise ValueError('cannot understand wav header') wfx = pywintypes.WAVEFORMATEX() wfx.wFormatTag = format wfx.nChannels = nchannels wfx.nSamplesPerSec = samplespersecond wfx.nAvgBytesPerSec = datarate wfx.nBlockAlign = blockalign wfx.wBitsPerSample = bitspersample return wfx, datalength
def _doTestEncrypt(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 ......') trailersize=pkg_size_info['SecurityTrailer'] encbuf=win32security.PySecBufferDescType() encbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA)) encbuf.append(win32security.PySecBufferType(trailersize, sspicon.SECBUFFER_TOKEN)) encbuf[0].Buffer=msg sspiclient.ctxt.EncryptMessage(0,encbuf,1) sspiserver.ctxt.DecryptMessage(encbuf,1) self.failUnlessEqual(msg, encbuf[0].Buffer) # and test the higher-level functions data_in = str2bytes("hello") data, sig = sspiclient.encrypt(data_in) self.assertEqual(sspiserver.decrypt(data, sig), data_in) data, sig = sspiserver.encrypt(data_in) self.assertEqual(sspiclient.decrypt(data, sig), data_in)
def test(verbose=0): import win32com.client.dynamic, win32com.client.connect import win32com.server.policy server = win32com.client.dynamic.Dispatch(win32com.server.util.wrap(ConnectableServer())) connection = win32com.client.connect.SimpleConnection() client = ConnectableClient() connection.Connect(server, client, IID_IConnectDemoEvents) CheckEvent(server, client, "Hello", verbose) CheckEvent(server, client, str2bytes("Here is a null>\x00<"), verbose) CheckEvent(server, client, u"Here is a null>\x00<", verbose) val = u"test-\xe0\xf2" # 2 extended characters. CheckEvent(server, client, val, verbose) if verbose: print "Everything seemed to work!"
def testEncrypt(self): fname = tempfile.mktemp("win32file_test") f = open(fname, "wb") f.write(str2bytes("hello")) f.close() f = None try: try: win32file.EncryptFile(fname) except win32file.error, details: if details.winerror != winerror.ERROR_ACCESS_DENIED: raise print "It appears this is not NTFS - cant encrypt/decrypt" win32file.DecryptFile(fname)
def testComToWin32(self): # Set the data via our DataObject do = TestDataObject("Hello from Python") do = WrapCOMObject(do, iid=pythoncom.IID_IDataObject) pythoncom.OleSetClipboard(do) # Then get it back via the standard win32 clipboard functions. win32clipboard.OpenClipboard() got = win32clipboard.GetClipboardData(win32con.CF_TEXT) # CF_TEXT gives bytes on py3k - use str2bytes() to ensure that's true. expected = str2bytes("Hello from Python") self.assertEqual(got, expected) # Now check unicode got = win32clipboard.GetClipboardData(win32con.CF_UNICODETEXT) self.assertEqual(got, "Hello from Python") win32clipboard.CloseClipboard()