comtypes 1.4.4__zip → 1.4.6__zip

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/automation.py

@@ -7,31 +7,24 @@ from ctypes import *
 from ctypes import _Pointer
 from _ctypes import CopyComPointer
 from ctypes.wintypes import DWORD, LONG, UINT, VARIANT_BOOL, WCHAR, WORD
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    List,
-    Optional,
-    TYPE_CHECKING,
-    Tuple,
-    Union as _UnionT,
-)
-
-from comtypes import BSTR, COMError, COMMETHOD, GUID, IID, IUnknown, STDMETHOD
+from typing import Any, ClassVar, Dict, List, Optional, TYPE_CHECKING, Type
+
+from comtypes import _CData, BSTR, COMError, COMMETHOD, GUID, IID, IUnknown, STDMETHOD
 from comtypes.hresult import *
+from comtypes._memberspec import _DispMemberSpec
 import comtypes.patcher
 import comtypes
 
 if TYPE_CHECKING:
     from comtypes import hints  # type: ignore
-
-try:
     from comtypes import _safearray
-except (ImportError, AttributeError):
+else:
+    try:
+        from comtypes import _safearray
+    except (ImportError, AttributeError):
 
-    class _safearray(object):
-        tagSAFEARRAY = None
+        class _safearray(object):
+            tagSAFEARRAY = None
 
 
 LCID = DWORD
@@ -404,6 +397,11 @@ class tagVARIANT(Structure):
                 ri.AddRef()
                 self._.pRecInfo = ri
                 self._.pvRecord = cast(value, c_void_p)
+            elif isinstance(ref, _Pointer) and isinstance(
+                ref.contents, _safearray.tagSAFEARRAY
+            ):
+                self.vt = VT_ARRAY | ref._vartype_ | VT_BYREF
+                self._.pparray = cast(value, POINTER(POINTER(_safearray.tagSAFEARRAY)))
             else:
                 self.vt = _ctype_to_vartype[type(ref)] | VT_BYREF
         elif isinstance(value, _Pointer):
@@ -421,6 +419,15 @@ class tagVARIANT(Structure):
                 ri.AddRef()
                 self._.pRecInfo = ri
                 self._.pvRecord = cast(value, c_void_p)
+            elif isinstance(ref, _safearray.tagSAFEARRAY):
+                obj = _midlSAFEARRAY(value._itemtype_).create(value.unpack())
+                memmove(byref(self._), byref(obj), sizeof(obj))
+                self.vt = VT_ARRAY | obj._vartype_
+            elif isinstance(ref, _Pointer) and isinstance(
+                ref.contents, _safearray.tagSAFEARRAY
+            ):
+                self.vt = VT_ARRAY | ref._vartype_ | VT_BYREF
+                self._.pparray = cast(value, POINTER(POINTER(_safearray.tagSAFEARRAY)))
             else:
                 self.vt = _ctype_to_vartype[type(ref)] | VT_BYREF
         else:
@@ -633,7 +640,7 @@ class _(object):
     def __setitem__(self, index, value):
         # This is to support the same sematics as a pointer instance:
         # variant[0] = value
-        self[index].value = value
+        self[index].value = value  # type: ignore
 
 
 ################################################################
@@ -773,28 +780,8 @@ DISPID_DESTRUCTOR = -7
 DISPID_COLLECT = -8
 
 
-RawGetIDsOfNamesFunc = Callable[
-    [_byref_type, "Array[c_wchar_p]", int, int, "Array[DISPID]"], int
-]
-# fmt: off
-RawInvokeFunc = Callable[
-    [
-        int, _byref_type, int, int,  # dispIdMember, riid, lcid, wFlags
-        _UnionT[_byref_type, DISPPARAMS],  # *pDispParams
-        _UnionT[_byref_type, VARIANT],  # pVarResult
-        _UnionT[_byref_type, EXCEPINFO, None],  # pExcepInfo
-        _UnionT[_byref_type, c_uint],  # puArgErr
-    ],
-    int,
-]
-# fmt: on
-
-
 class IDispatch(IUnknown):
-    _disp_methods_: ClassVar[List[comtypes._DispMemberSpec]]
-    _GetTypeInfo: Callable[[int, int], IUnknown]
-    __com_GetIDsOfNames: RawGetIDsOfNamesFunc
-    __com_Invoke: RawInvokeFunc
+    _disp_methods_: ClassVar[List[_DispMemberSpec]]
 
     _iid_ = GUID("{00020400-0000-0000-C000-000000000046}")
     _methods_ = [
@@ -835,7 +822,7 @@ class IDispatch(IUnknown):
         """Return type information.  Index 0 specifies typeinfo for IDispatch"""
         import comtypes.typeinfo
 
-        result = self._GetTypeInfo(index, lcid)
+        result = self._GetTypeInfo(index, lcid)  # type: ignore
         return result.QueryInterface(comtypes.typeinfo.ITypeInfo)
 
     def GetIDsOfNames(self, *names: str, **kw: Any) -> List[int]:
@@ -844,7 +831,7 @@ class IDispatch(IUnknown):
         assert not kw
         arr = (c_wchar_p * len(names))(*names)
         ids = (DISPID * len(names))()
-        self.__com_GetIDsOfNames(riid_null, arr, len(names), lcid, ids)
+        self.__com_GetIDsOfNames(riid_null, arr, len(names), lcid, ids)  # type: ignore
         return ids[:]
 
     def _invoke(self, memid: int, invkind: int, lcid: int, *args: Any) -> Any:
@@ -864,7 +851,9 @@ class IDispatch(IUnknown):
                 dp.rgdispidNamedArgs = pointer(DISPID(DISPID_PROPERTYPUT))
             dp.rgvarg = array
 
-        self.__com_Invoke(memid, riid_null, lcid, invkind, dp, var, None, argerr)
+        self.__com_Invoke(  # type: ignore
+            memid, riid_null, lcid, invkind, dp, var, None, argerr
+        )
         return var._get_value(dynamic=True)
 
     def __make_dp(self, _invkind: int, *args: Any) -> DISPPARAMS:
@@ -900,7 +889,7 @@ class IDispatch(IUnknown):
         excepinfo = EXCEPINFO()
         argerr = c_uint()
         try:
-            self.__com_Invoke(
+            self.__com_Invoke(  # type: ignore
                 dispid,
                 riid_null,
                 _lcid,
@@ -964,7 +953,7 @@ _arraycode_to_vartype = {
     "B": VT_UI1,
 }
 
-_ctype_to_vartype = {
+_ctype_to_vartype: Dict[Type[_CData], int] = {
     c_byte: VT_I1,
     c_ubyte: VT_UI1,
     c_short: VT_I2,
@@ -1000,7 +989,7 @@ _ctype_to_vartype = {
     # POINTER(IDispatch): VT_DISPATCH,
 }
 
-_vartype_to_ctype = {}
+_vartype_to_ctype: Dict[int, Type[_CData]] = {}
 for c, v in _ctype_to_vartype.items():
     _vartype_to_ctype[v] = c
 _vartype_to_ctype[VT_INT] = _vartype_to_ctype[VT_I4]

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/client/__init__.py

@@ -12,15 +12,8 @@ import ctypes
 import logging
 import os
 import sys
-from typing import (
-    Any,
-    Optional,
-    overload,
-    Type,
-    TYPE_CHECKING,
-    TypeVar,
-    Union as _UnionT,
-)
+from typing import Any, overload, TypeVar, TYPE_CHECKING
+from typing import Optional, Type, Union as _UnionT
 
 import comtypes
 from comtypes.hresult import *

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/client/_code_cache.py

@@ -34,10 +34,10 @@ def _find_gen_dir():
     appended to comtypes.gen.__path__ .
 
     For a Python script using comtypes, the additional directory is
-    '%APPDATA%\<username>\Python\Python25\comtypes_cache'.
+    '%APPDATA%\\<username>\\Python\\Python25\\comtypes_cache'.
 
     For an executable frozen with py2exe, the additional directory is
-    '%TEMP%\comtypes_cache\<imagebasename>-25'.
+    '%TEMP%\\comtypes_cache\\<imagebasename>-25'.
     """
     _create_comtypes_gen_package()
     from comtypes import gen

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/client/_generate.py

@@ -262,7 +262,7 @@ def _get_known_namespaces() -> Tuple[
     Note:
         The interfaces that should be included in `__known_symbols__` should be limited
         to those that can be said to be bound to the design concept of COM, such as
-        `IUnknown`, and those defined in `objidl` and `oaidl`.
+        `IUnknown`, `IDispatch` and `ITypeInfo`.
         `comtypes` does NOT aim to statically define all COM object interfaces in
         its repository.
     """
@@ -272,6 +272,7 @@ def _get_known_namespaces() -> Tuple[
         "comtypes.persist",
         "comtypes.typeinfo",
         "comtypes.automation",
+        "comtypes.stream",
         "comtypes",
         "ctypes.wintypes",
         "ctypes",

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/hints.pyi

@@ -1,21 +1,12 @@
 # This stub contains...
 # - symbols those what might occur recursive imports in runtime.
 # - utilities for type hints.
+import ctypes
 import sys
-from typing import (
-    Any,
-    Callable,
-    Generic,
-    Iterator,
-    List,
-    NoReturn,
-    Tuple,
-    Type,
-    TypeVar,
-    Optional,
-    overload,
-    Union as _UnionT,
-)
+from typing import Any as Any, ClassVar, Generic, NoReturn, TypeVar, overload
+from typing import Optional, Union as _UnionT
+from typing import List, Tuple as Tuple, Type
+from typing import Callable, Iterator, Sequence
 
 if sys.version_info >= (3, 8):
     from typing import Protocol
@@ -32,14 +23,16 @@ else:
     from typing_extensions import Concatenate, ParamSpec, TypeAlias
     from typing_extensions import TypeGuard as TypeGuard
 if sys.version_info >= (3, 11):
-    from typing import Self
+    from typing import Self as Self
 else:
-    from typing_extensions import Self
+    from typing_extensions import Self as Self
 
 import comtypes
+from comtypes import IUnknown as IUnknown, GUID as GUID
 from comtypes.automation import IDispatch as IDispatch, VARIANT as VARIANT
 from comtypes.server import IClassFactory as IClassFactory
 from comtypes.typeinfo import ITypeInfo as ITypeInfo
+from comtypes._safearray import tagSAFEARRAY as tagSAFEARRAY
 
 Incomplete: TypeAlias = Any
 """The type symbol is used temporarily until the COM library parsers or
@@ -51,6 +44,35 @@ Hresult: TypeAlias = int
 arguments and with `HRESULT` as its return type in its COM method definition.
 """
 
+_CT = TypeVar("_CT", bound=ctypes._CData)
+_T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
+_T_Struct = TypeVar("_T_Struct", bound=ctypes.Structure)
+
+class LP_SAFEARRAY(ctypes._Pointer[tagSAFEARRAY], Generic[_CT]):
+    contents: tagSAFEARRAY
+    _itemtype_: ClassVar[_CT]  # type: ignore
+    _vartype_: ClassVar[int]
+    _needsfree: ClassVar[bool]
+
+    @overload
+    @classmethod
+    def create(
+        cls: Type[LP_SAFEARRAY[ctypes._Pointer[_T_IUnknown]]],
+        value: Sequence[_T_IUnknown],
+        extra: ctypes._Pointer[GUID] = ...,
+    ) -> LP_SAFEARRAY[ctypes._Pointer[_T_IUnknown]]: ...
+    @overload
+    @classmethod
+    def create(cls, value: Sequence[_CT], extra: Any = ...) -> LP_SAFEARRAY[_CT]: ...
+    @overload
+    def unpack(
+        self: LP_SAFEARRAY[ctypes._Pointer[_T_IUnknown]],
+    ) -> Sequence[_T_IUnknown]: ...
+    @overload
+    def unpack(self: LP_SAFEARRAY[_T_Struct]) -> Sequence[_T_Struct]: ...
+    @overload
+    def unpack(self) -> Sequence[Any]: ...
+
 _T_coclass = TypeVar("_T_coclass", bound=comtypes.CoClass)
 
 class FirstComItfOf(Generic[_T_coclass]):

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/safearray.py

@@ -1,10 +1,17 @@
 import threading
 import array
+from typing import TYPE_CHECKING
 import comtypes
 from ctypes import POINTER, Structure, byref, cast, c_long, memmove, pointer, sizeof
 from comtypes import _safearray, IUnknown, com_interface_registry
 from comtypes.patcher import Patch
 
+if TYPE_CHECKING:
+    from typing import Type, TypeVar
+    from comtypes import hints  # type: ignore
+
+    _CT = TypeVar("_CT", bound=comtypes._CData)
+
 _safearray_type_cache = {}
 
 
@@ -49,18 +56,18 @@ safearray_as_ndarray = _SafeArrayAsNdArrayContextManager()
 
 ################################################################
 # This is THE PUBLIC function: the gateway to the SAFEARRAY functionality.
-def _midlSAFEARRAY(itemtype):
+def _midlSAFEARRAY(itemtype: "Type[_CT]") -> "Type[hints.LP_SAFEARRAY[_CT]]":
     """This function mimics the 'SAFEARRAY(aType)' IDL idiom.  It
     returns a subtype of SAFEARRAY, instances will be built with a
     typecode VT_...  corresponding to the aType, which must be one of
     the supported ctypes.
     """
     try:
-        return POINTER(_safearray_type_cache[itemtype])
+        return POINTER(_safearray_type_cache[itemtype])  # type: ignore
     except KeyError:
         sa_type = _make_safearray_type(itemtype)
         _safearray_type_cache[itemtype] = sa_type
-        return POINTER(sa_type)
+        return POINTER(sa_type)  # type: ignore
 
 
 def _make_safearray_type(itemtype):
@@ -109,7 +116,7 @@ def _make_safearray_type(itemtype):
         _needsfree = False
 
         @classmethod
-        def create(cls, value, extra=None):
+        def create(cls, value, extra=extra):
             """Create a POINTER(SAFEARRAY_...) instance of the correct
             type; value is an object containing the items to store.
 

comtypes-1.4.6/comtypes/stream.py

@@ -0,0 +1,65 @@
+from ctypes import Array, c_ubyte, c_ulong, HRESULT, POINTER, pointer
+from typing import Tuple, TYPE_CHECKING
+
+from comtypes import COMMETHOD, GUID, IUnknown
+
+
+class ISequentialStream(IUnknown):
+    """Defines methods for the stream objects in sequence."""
+
+    _iid_ = GUID("{0C733A30-2A1C-11CE-ADE5-00AA0044773D}")
+    _idlflags_ = []
+
+    _methods_ = [
+        # Note that these functions are called `Read` and `Write` in Microsoft's documentation,
+        # see https://learn.microsoft.com/en-us/windows/win32/api/objidl/nn-objidl-isequentialstream.
+        # However, the comtypes code generation detects these as `RemoteRead` and `RemoteWrite`
+        # for very subtle reasons, see e.g. https://stackoverflow.com/q/19820999/. We will not
+        # rename these in this manual import for the sake of consistency.
+        COMMETHOD(
+            [],
+            HRESULT,
+            "RemoteRead",
+            # This call only works if `pv` is pre-allocated with `cb` bytes,
+            # which cannot be done by the high level function generated by metaclasses.
+            # Therefore, we override the high level function to implement this behaviour
+            # and then delegate the call the raw COM method.
+            (["out"], POINTER(c_ubyte), "pv"),
+            (["in"], c_ulong, "cb"),
+            (["out"], POINTER(c_ulong), "pcbRead"),
+        ),
+        COMMETHOD(
+            [],
+            HRESULT,
+            "RemoteWrite",
+            (["in"], POINTER(c_ubyte), "pv"),
+            (["in"], c_ulong, "cb"),
+            (["out"], POINTER(c_ulong), "pcbWritten"),
+        ),
+    ]
+
+    def RemoteRead(self, cb: int) -> Tuple["Array[c_ubyte]", int]:
+        """Reads a specified number of bytes from the stream object into memory
+        starting at the current seek pointer.
+        """
+        # Behaves as if `pv` is pre-allocated with `cb` bytes by the high level func.
+        pv = (c_ubyte * cb)()
+        pcb_read = pointer(c_ulong(0))
+        self.__com_RemoteRead(pv, c_ulong(cb), pcb_read)  # type: ignore
+        # return both `out` parameters
+        return pv, pcb_read.contents.value
+
+    if TYPE_CHECKING:
+
+        def RemoteWrite(self, pv: "Array[c_ubyte]", cb: int) -> int:
+            """Writes a specified number of bytes into the stream object starting at
+            the current seek pointer.
+            """
+            ...
+
+
+# fmt: off
+__known_symbols__ = [
+    'ISequentialStream',
+]
+# fmt: on

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/test/test_client.py

@@ -71,6 +71,12 @@ class Test_GetModule(ut.TestCase):
         # the `_Pointer` interface, rather than importing `_Pointer` from `ctypes`.
         self.assertTrue(issubclass(mod._Pointer, comtypes.IUnknown))
 
+    def test_portabledeviceapi(self):
+        mod = comtypes.client.GetModule("portabledeviceapi.dll")
+        from comtypes.stream import ISequentialStream
+
+        self.assertTrue(issubclass(mod.IStream, ISequentialStream))
+
     def test_no_replacing_Patch_namespace(self):
         # NOTE: An object named `Patch` is defined in some dll.
         # Depending on how the namespace is defined in the static module,
@@ -117,6 +123,11 @@ class Test_KnownSymbols(ut.TestCase):
 
         self._doit(comtypes)
 
+    def test_symbols_in_comtypes_stream(self):
+        import comtypes.stream
+
+        self._doit(comtypes.stream)
+
     def test_symbols_in_comtypes_automation(self):
         import comtypes.automation
 

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/test/test_dispifc_records.py

@@ -26,7 +26,7 @@ class Test_DispMethods(unittest.TestCase):
     def _create_dispifc(self) -> "ComtypesCppTestSrvLib.IDispRecordParamTest":
         # Explicitely ask for the dispinterface of the component.
         return CreateObject(
-            "Comtypes.DispIfcParamTests",
+            "Comtypes.DispRecordParamTest",
             clsctx=CLSCTX_LOCAL_SERVER,
             interface=ComtypesCppTestSrvLib.IDispRecordParamTest,
         )

comtypes-1.4.6/comtypes/test/test_dispifc_safearrays.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+from ctypes import byref, c_double, pointer
+import unittest
+
+import comtypes
+import comtypes.safearray
+from comtypes import CLSCTX_LOCAL_SERVER
+from comtypes.client import CreateObject, GetModule
+
+ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
+
+try:
+    GetModule((ComtypesCppTestSrvLib_GUID, 1, 0, 0))
+    import comtypes.gen.ComtypesCppTestSrvLib as ComtypesCppTestSrvLib
+
+    IMPORT_FAILED = False
+except (ImportError, OSError):
+    IMPORT_FAILED = True
+
+
+@unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+class Test_DispMethods(unittest.TestCase):
+    """Test dispmethods with safearray and safearray pointer parameters."""
+
+    UNPACKED_ZERO_VALS = tuple(0.0 for _ in range(10))
+    UNPACKED_CONSECUTIVE_VALS = tuple(float(i) for i in range(10))
+
+    def _create_dispifc(self) -> "ComtypesCppTestSrvLib.IDispSafearrayParamTest":
+        # Explicitely ask for the dispinterface of the component.
+        return CreateObject(
+            "Comtypes.DispSafearrayParamTest",
+            clsctx=CLSCTX_LOCAL_SERVER,
+            interface=ComtypesCppTestSrvLib.IDispSafearrayParamTest,
+        )
+
+    def _create_zero_array(self):
+        return comtypes.safearray._midlSAFEARRAY(c_double).create(
+            [c_double() for _ in range(10)]
+        )
+
+    def _create_consecutive_array(self):
+        return comtypes.safearray._midlSAFEARRAY(c_double).create(
+            [c_double(i) for i in range(10)]
+        )
+
+    def test_inout_byref(self):
+        dispifc = self._create_dispifc()
+        # Passing a safearray by reference to a method that has declared the parameter
+        # as [in, out] we expect modifications of the safearray on the server side to
+        # also change the safearray on the client side.
+        test_array = self._create_zero_array()
+        self.assertEqual(test_array.unpack(), self.UNPACKED_ZERO_VALS)
+        dispifc.InitArray(byref(test_array))
+        self.assertEqual(test_array.unpack(), self.UNPACKED_CONSECUTIVE_VALS)
+
+    def test_inout_pointer(self):
+        dispifc = self._create_dispifc()
+        # Passing a safearray pointer to a method that has declared the parameter
+        # as [in, out] we expect modifications of the safearray on the server side to
+        # also change the safearray on the client side.
+        test_array = self._create_zero_array()
+        self.assertEqual(test_array.unpack(), self.UNPACKED_ZERO_VALS)
+        dispifc.InitArray(pointer(test_array))
+        self.assertEqual(test_array.unpack(), self.UNPACKED_CONSECUTIVE_VALS)
+
+    def test_in_safearray(self):
+        # Passing a safearray to a method that has declared the parameter just as [in]
+        # we expect modifications of the safearray on the server side NOT to change
+        # the safearray on the client side.
+        # We also need to test if the safearray gets properly passed to the method on
+        # the server side. For this, the 'VerifyArray' method returns 'True' if
+        # the safearray items have values equal to the initialization values
+        # provided by 'InitArray'.
+        for sa, expected, unpacked_content in [
+            (self._create_consecutive_array(), True, self.UNPACKED_CONSECUTIVE_VALS),
+            # Also perform the inverted test. For this, create a safearray with zeros.
+            (self._create_zero_array(), False, self.UNPACKED_ZERO_VALS),
+        ]:
+            with self.subTest(expected=expected, unpacked_content=unpacked_content):
+                # Perform the check on initialization values.
+                self.assertEqual(self._create_dispifc().VerifyArray(sa), expected)
+                # Check if the safearray is unchanged although the method
+                # modifies the safearray on the server side.
+                self.assertEqual(sa.unpack(), unpacked_content)
+
+
+if __name__ == "__main__":
+    unittest.main()

comtypes-1.4.6/comtypes/test/test_istream.py

@@ -0,0 +1,53 @@
+import unittest as ut
+
+from ctypes import POINTER, byref, c_bool, c_ubyte
+import comtypes
+import comtypes.client
+
+comtypes.client.GetModule("portabledeviceapi.dll")
+from comtypes.gen.PortableDeviceApiLib import IStream
+
+
+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(0)
+        # Move the stream back to the beginning
+        STREAM_SEEK_SET = 0
+        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)
+
+
+if __name__ == "__main__":
+    ut.main()

comtypes-1.4.6/comtypes/test/test_midl_safearray_create.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+from ctypes import c_int, pointer, POINTER
+import unittest
+
+import comtypes
+import comtypes.safearray
+from comtypes import CLSCTX_INPROC_SERVER, CLSCTX_LOCAL_SERVER
+from comtypes.client import CreateObject, GetModule
+import comtypes.typeinfo
+
+GetModule("UIAutomationCore.dll")
+from comtypes.gen.UIAutomationClient import CUIAutomation, IUIAutomation
+
+ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
+
+try:
+    GetModule((ComtypesCppTestSrvLib_GUID, 1, 0, 0))
+    from comtypes.gen.ComtypesCppTestSrvLib import StructRecordParamTest
+    from comtypes.gen.ComtypesCppTestSrvLib import IDispSafearrayParamTest
+
+    IMPORT_FAILED = False
+except (ImportError, OSError):
+    IMPORT_FAILED = True
+
+
+class Test_midlSAFEARRAY_create(unittest.TestCase):
+    def test_iunk(self):
+        extra = pointer(IUIAutomation._iid_)
+        iuia = CreateObject(
+            CUIAutomation().IPersist_GetClassID(),
+            interface=IUIAutomation,
+            clsctx=CLSCTX_INPROC_SERVER,
+        )
+        sa_type = comtypes.safearray._midlSAFEARRAY(POINTER(IUIAutomation))
+        for ptn, sa in [
+            ("with extra", sa_type.create([iuia], extra=extra)),
+            ("without extra", sa_type.create([iuia])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, POINTER(IUIAutomation))
+
+    @unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+    def test_idisp(self):
+        extra = pointer(IDispSafearrayParamTest._iid_)
+        idisp = CreateObject(
+            "Comtypes.DispSafearrayParamTest",
+            clsctx=CLSCTX_LOCAL_SERVER,
+            interface=IDispSafearrayParamTest,
+        )
+        sa_type = comtypes.safearray._midlSAFEARRAY(POINTER(IDispSafearrayParamTest))
+        for ptn, sa in [
+            ("with extra", sa_type.create([idisp], extra=extra)),
+            ("without extra", sa_type.create([idisp])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, POINTER(IDispSafearrayParamTest))
+
+    @unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+    def test_record(self):
+        extra = comtypes.typeinfo.GetRecordInfoFromGuids(
+            *StructRecordParamTest._recordinfo_
+        )
+        record = StructRecordParamTest()
+        record.question = "The meaning of life, the universe and everything?"
+        record.answer = 42
+        record.needs_clarification = True
+        sa_type = comtypes.safearray._midlSAFEARRAY(StructRecordParamTest)
+        for ptn, sa in [
+            ("with extra", sa_type.create([record], extra=extra)),
+            ("without extra", sa_type.create([record])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, StructRecordParamTest)
+                self.assertEqual(
+                    unpacked.question,
+                    "The meaning of life, the universe and everything?",
+                )
+                self.assertEqual(unpacked.answer, 42)
+                self.assertEqual(unpacked.needs_clarification, True)
+
+    def test_ctype(self):
+        extra = None
+        cdata = c_int(1)
+        sa_type = comtypes.safearray._midlSAFEARRAY(c_int)
+        for ptn, sa in [
+            ("with extra", sa_type.create([cdata], extra=extra)),
+            ("without extra", sa_type.create([cdata])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, int)
+                self.assertEqual(unpacked, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()