comtypes 1.4.7__zip → 1.4.9__zip

comtypes-1.4.9/comtypes/test/test_stream.py

@@ -0,0 +1,131 @@
+import unittest as ut
+
+from ctypes import POINTER, byref, c_bool, c_ubyte, c_ulonglong, oledll, pointer
+import comtypes
+import comtypes.client
+
+comtypes.client.GetModule("portabledeviceapi.dll")
+from comtypes.gen.PortableDeviceApiLib import IStream
+
+
+STGC_DEFAULT = 0
+STREAM_SEEK_SET = 0
+STREAM_SEEK_CUR = 1
+STREAM_SEEK_END = 2
+
+
+def _create_stream() -> IStream:
+    # Create an IStream
+    stream = POINTER(IStream)()  # type: ignore
+    comtypes._ole32.CreateStreamOnHGlobal(None, c_bool(True), byref(stream))
+    return stream  # type: ignore
+
+
+class Test_RemoteWrite(ut.TestCase):
+    def test_RemoteWrite(self):
+        stream = _create_stream()
+        test_data = "Some data".encode("utf-8")
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+
+        written = stream.RemoteWrite(pv, len(test_data))
+
+        # Verification
+        self.assertEqual(written, len(test_data))
+
+
+class Test_RemoteRead(ut.TestCase):
+    def test_RemoteRead(self):
+        stream = _create_stream()
+        test_data = "Some data".encode("utf-8")
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        stream.RemoteWrite(pv, len(test_data))
+
+        # Make sure the data actually gets written before trying to read back
+        stream.Commit(STGC_DEFAULT)
+        # Move the stream back to the beginning
+        stream.RemoteSeek(0, STREAM_SEEK_SET)
+
+        buffer_size = 1024
+
+        read_buffer, data_read = stream.RemoteRead(buffer_size)
+
+        # Verification
+        self.assertEqual(data_read, len(test_data))
+        self.assertEqual(bytearray(read_buffer)[0:data_read], test_data)
+
+
+class Test_RemoteSeek(ut.TestCase):
+    def _create_sample_stream(self) -> IStream:
+        stream = _create_stream()
+        test_data = b"spam egg bacon ham"
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        stream.RemoteWrite(pv, len(test_data))
+        stream.Commit(STGC_DEFAULT)
+        return stream
+
+    def test_takes_STREAM_SEEK_SET_as_origin(self):
+        stream = self._create_sample_stream()
+        newpos = stream.RemoteSeek(9, STREAM_SEEK_SET)
+        self.assertEqual(newpos, 9)
+        buf, read = stream.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], b"bacon ham")
+
+    def test_takes_STREAM_SEEK_CUR_as_origin(self):
+        stream = self._create_sample_stream()
+        stream.RemoteSeek(8, STREAM_SEEK_SET)
+        newpos = stream.RemoteSeek(7, STREAM_SEEK_CUR)
+        self.assertEqual(newpos, 15)
+        buf, read = stream.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], b"ham")
+
+    def test_takes_STREAM_SEEK_END_as_origin(self):
+        stream = self._create_sample_stream()
+        stream.RemoteSeek(8, STREAM_SEEK_SET)
+        newpos = stream.RemoteSeek(-13, STREAM_SEEK_END)
+        self.assertEqual(newpos, 5)
+        buf, read = stream.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], b"egg bacon ham")
+
+
+class Test_SetSize(ut.TestCase):
+    def test_SetSize(self):
+        stream = _create_stream()
+        stream.SetSize(42)
+        pui = pointer(c_ulonglong())
+        oledll.shlwapi.IStream_Size(stream, pui)
+        self.assertEqual(pui.contents.value, 42)
+
+
+class Test_RemoteCopyTo(ut.TestCase):
+    def test_RemoteCopyTo(self):
+        src = _create_stream()
+        dst = _create_stream()
+        test_data = b"parrot"
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        src_written = src.RemoteWrite(pv, len(test_data))
+        src.Commit(STGC_DEFAULT)
+        src.RemoteSeek(0, STREAM_SEEK_SET)
+        cpy_read, cpy_written = src.RemoteCopyTo(dst, src_written)
+        self.assertEqual(cpy_read, len(test_data))
+        self.assertEqual(cpy_written, len(test_data))
+        dst.Commit(STGC_DEFAULT)
+        dst.RemoteSeek(0, STREAM_SEEK_SET)
+        dst_buf, dst_read = dst.RemoteRead(1024)
+        self.assertEqual(bytearray(dst_buf)[0:dst_read], test_data)
+
+
+class Test_Clone(ut.TestCase):
+    def test_Clone(self):
+        orig = _create_stream()
+        test_data = b"spam egg bacon ham"
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        orig.RemoteWrite(pv, len(test_data))
+        orig.Commit(STGC_DEFAULT)
+        orig.RemoteSeek(0, STREAM_SEEK_SET)
+        new_stm = orig.Clone()
+        buf, read = new_stm.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], test_data)
+
+
+if __name__ == "__main__":
+    ut.main()

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/test_typeannotator.py

@@ -7,6 +7,7 @@ from comtypes.tools.tlbparser import (
     HRESULT_type,
     VARIANT_type,
     VARIANT_BOOL_type,
+    void_type,
 )
 
 
@@ -20,7 +21,6 @@ idispatch_type = typedesc.ComInterface(
     ["restricted"],
     None,
 )
-void_type = typedesc.FundamentalType("void", 0, 0)
 
 
 class Test_AvoidUsingKeywords(unittest.TestCase):

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/test_urlhistory.py

@@ -9,6 +9,7 @@ from comtypes.patcher import Patch
 GetModule(os.path.join(os.path.dirname(__file__), "urlhist.tlb"))
 from comtypes.gen import urlhistLib
 
+
 # The pwcsTitle and pwcsUrl fields of the _STATURL structure must be
 # freed by the caller.  The only way to do this without patching the
 # generated code directly is to monkey-patch the

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/test_variant.py

@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import datetime
 import decimal
 import sys
@@ -196,23 +194,6 @@ class VariantTestCase(unittest.TestCase):
         v.value = ""
         self.assertEqual(v.vt, VT_BSTR)
 
-    @unittest.skip(
-        "Fails on creating `TestComServerLib.TestComServer`.  Library not registered."
-    )
-    def test_UDT(self):
-        from comtypes.gen.TestComServerLib import MYCOLOR
-
-        v = VARIANT(MYCOLOR(red=1.0, green=2.0, blue=3.0))
-        value = v.value
-        self.assertEqual((1.0, 2.0, 3.0), (value.red, value.green, value.blue))
-
-        def func():
-            v = VARIANT(MYCOLOR(red=1.0, green=2.0, blue=3.0))
-            return v.value
-
-        bytes = find_memleak(func)
-        self.assertFalse(bytes, "Leaks %d bytes" % bytes)
-
     def test_ctypes_in_variant(self):
         v = VARIANT()
         objs = [

comtypes-1.4.9/comtypes/test/test_w_getopt.py

@@ -0,0 +1,29 @@
+import unittest
+
+from comtypes.server.w_getopt import GetoptError, w_getopt
+
+
+class TestCase(unittest.TestCase):
+    def test_1(self):
+        args = "-embedding spam /RegServer foo /UnregSERVER blabla".split()
+        opts, args = w_getopt(args, "regserver unregserver embedding".split())
+        self.assertEqual(
+            opts, [("embedding", ""), ("regserver", ""), ("unregserver", "")]
+        )
+        self.assertEqual(args, ["spam", "foo", "blabla"])
+
+    def test_2(self):
+        args = "/TLB Hello.Tlb HELLO.idl".split()
+        opts, args = w_getopt(args, ["tlb:"])
+        self.assertEqual(opts, [("tlb", "Hello.Tlb")])
+        self.assertEqual(args, ["HELLO.idl"])
+
+    def test_3(self):
+        # Invalid option
+        self.assertRaises(
+            GetoptError, w_getopt, "/TLIB hello.tlb hello.idl".split(), ["tlb:"]
+        )
+
+    def test_4(self):
+        # Missing argument
+        self.assertRaises(GetoptError, w_getopt, "/TLB".split(), ["tlb:"])

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/test_win32com_interop.py

@@ -1,19 +1,37 @@
 import unittest
-
-from ctypes import PyDLL, py_object, c_void_p, byref, POINTER
+from ctypes import POINTER, PyDLL, byref, c_void_p, py_object
 from ctypes.wintypes import BOOL
 
-from comtypes import IUnknown
+from comtypes import COMObject, IUnknown
+from comtypes.automation import VARIANT, IDispatch
 from comtypes.client import CreateObject
-from comtypes.automation import IDispatch
-from comtypes.test import requires
 
-requires("pythoncom")
 try:
     import pythoncom
     import win32com.client
 
-    skip = False
+    IMPORT_FAILED = False
+    # pywin32 is available.  The pythoncom dll contains two handy
+    # exported functions that allow to create a VARIANT from a Python
+    # object, also a function that unpacks a VARIANT into a Python
+    # object.
+    #
+    # This allows us to create und unpack SAFEARRAY instances
+    # contained in VARIANTs, and check for consistency with the
+    # comtypes code.
+    _dll = PyDLL(pythoncom.__file__)
+
+    # c:/sf/pywin32/com/win32com/src/oleargs.cpp 213
+    # PyObject *PyCom_PyObjectFromVariant(const VARIANT *var)
+    unpack = _dll.PyCom_PyObjectFromVariant
+    unpack.restype = py_object
+    unpack.argtypes = (POINTER(VARIANT),)
+
+    # c:/sf/pywin32/com/win32com/src/oleargs.cpp 54
+    # BOOL PyCom_VariantFromPyObject(PyObject *obj, VARIANT *var)
+    _pack = _dll.PyCom_VariantFromPyObject
+    _pack.argtypes = py_object, POINTER(VARIANT)
+    _pack.restype = BOOL
     # We use the PyCom_PyObjectFromIUnknown function in pythoncom25.dll to
     # convert a comtypes COM pointer into a pythoncom COM pointer.
     # Fortunately this function is exported by the dll...
@@ -30,17 +48,58 @@ except ImportError:
     # if it is available since pythoncom is not a project dependency and adding tests depending
     # on the vagaries of various testing environments is not deterministic.
     # TODO: Evaluate if we should just remove this test or what.
-    skip = True
+    IMPORT_FAILED = True
 
 
 def setUpModule():
-    if skip:
+    if IMPORT_FAILED:
         raise unittest.SkipTest(
             "This test requires the pythoncom library installed.  If this is "
             "important tests then we need to add dev dependencies to the project that include pythoncom."
         )
 
 
+################################################################
+
+
+def pack(obj):
+    var = VARIANT()
+    _pack(obj, byref(var))
+    return var
+
+
+class PyWinSafeArrayTest(unittest.TestCase):
+    def test_1dim(self):
+        data = (1, 2, 3)
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_2dim(self):
+        data = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_3dim(self):
+        data = (((1, 2), (3, 4), (5, 6)), ((7, 8), (9, 10), (11, 12)))
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_4dim(self):
+        data = (
+            (((1, 2), (3, 4)), ((5, 6), (7, 8))),
+            (((9, 10), (11, 12)), ((13, 14), (15, 16))),
+        )
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+
+################################################################
+
+
 def comtypes2pywin(ptr, interface=None):
     """Convert a comtypes pointer 'ptr' into a pythoncom
     PyI<interface> object.
@@ -56,9 +115,6 @@ def comtypes2pywin(ptr, interface=None):
     return _PyCom_PyObjectFromIUnknown(ptr, byref(interface._iid_), True)
 
 
-################################################################
-
-
 def comtypes_get_refcount(ptr):
     """Helper function for testing: return the COM reference count of
     a comtypes COM object"""
@@ -66,9 +122,6 @@ def comtypes_get_refcount(ptr):
     return ptr.Release()
 
 
-from comtypes import COMObject
-
-
 class MyComObject(COMObject):
     """A completely trivial COM object implementing IDispatch. Calling
     any methods will return the error code E_NOTIMPL (except the
@@ -77,42 +130,33 @@ class MyComObject(COMObject):
     _com_interfaces_ = [IDispatch]
 
 
-################################################################
-
-
-class Test(unittest.TestCase):
-    def tearDown(self):
-        if hasattr(self, "ie"):
-            self.ie.Quit()
-            del self.ie
-
+class ConvertComtypesPtrToPythonComObjTest(unittest.TestCase):
     def test_mycomobject(self):
         o = MyComObject()
         p = comtypes2pywin(o, IDispatch)
         disp = win32com.client.Dispatch(p)
         self.assertEqual(repr(disp), "<COMObject <unknown>>")
 
-    def test_ie(self):
-        # Convert a comtypes COM interface pointer into a win32com COM
-        # pointer.
-        ie = self.ie = CreateObject("InternetExplorer.Application")
+    def test_refcount(self):
+        # Convert a comtypes COM interface pointer into a win32com COM pointer.
+        dic = CreateObject("Scripting.Dictionary")
         # The COM refcount of the created object is 1:
-        self.assertEqual(comtypes_get_refcount(ie), 1)
-        # IE starts invisible:
-        self.assertEqual(ie.Visible, False)
+        self.assertEqual(comtypes_get_refcount(dic), 1)
+        dic["foo"] = "bar"
+        self.assertEqual(dic.Item("foo"), "bar")
 
         # Create a pythoncom PyIDispatch object from it:
-        p = comtypes2pywin(ie, interface=IDispatch)
-        self.assertEqual(comtypes_get_refcount(ie), 2)
+        p = comtypes2pywin(dic, interface=IDispatch)
+        self.assertEqual(comtypes_get_refcount(dic), 2)
 
         # Make it usable...
         disp = win32com.client.Dispatch(p)
-        self.assertEqual(comtypes_get_refcount(ie), 2)
-        self.assertEqual(disp.Visible, False)
+        self.assertEqual(comtypes_get_refcount(dic), 2)
+        self.assertEqual(disp.Item("foo"), "bar")
 
         # Cleanup and make sure that the COM refcounts are correct
         del p, disp
-        self.assertEqual(comtypes_get_refcount(ie), 1)
+        self.assertEqual(comtypes_get_refcount(dic), 1)
 
 
 if __name__ == "__main__":

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/test_wmi.py

@@ -1,9 +1,6 @@
 import unittest as ut
 
 from comtypes.client import CoGetObject
-from comtypes.test import requires
-
-requires("time")
 
 
 # WMI has dual interfaces.