comtypes 1.4.11__zip → 1.4.12__zip

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/client/lazybind.py

@@ -12,7 +12,7 @@ from comtypes.automation import (
 from comtypes.typeinfo import FUNC_DISPATCH, FUNC_PUREVIRTUAL
 
 
-class FuncDesc(object):
+class FuncDesc:
     """Stores important FUNCDESC properties by copying them from a
     real FUNCDESC instance.
     """
@@ -28,7 +28,7 @@ class FuncDesc(object):
 _all_slice = slice(None, None, None)
 
 
-class NamedProperty(object):
+class NamedProperty:
     def __init__(self, disp, get, put, putref):
         self.get = get
         self.put = put
@@ -83,7 +83,7 @@ class NamedProperty(object):
 #    objects do not (could be added, would probably be expensive)
 
 
-class Dispatch(object):
+class Dispatch:
     """Dynamic dispatch for an object the exposes type information.
     Binding at runtime is done via ITypeComp::Bind calls.
     """

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/errorinfo.py

@@ -126,7 +126,7 @@ def ReportError(
             clsid = GUID(clsid)
         try:
             progid = clsid.as_progid()
-        except WindowsError:
+        except OSError:
             pass
         else:
             # progid for the class or application that created the error

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/hresult.py

@@ -89,3 +89,71 @@ def HRESULT_FROM_WIN32(x: int) -> int:
 # them into HRESULT values by setting the high bit, ensuring a consistent way
 # to indicate failure across these APIs.
 RPC_S_SERVER_UNAVAILABLE = -2147023174  # 0x800706BA (WIN32: 1722 0x6BA)
+
+
+################################################################
+# signed32bithex
+#
+# When using this package, error codes for exceptions like
+# `COMError` or `WindowsError` are base10 integers.
+#
+# However, as shown below, many technical references represent
+# HRESULT values using signed 32-bit hexadecimal notation:
+# https://learn.microsoft.com/en-us/windows/win32/seccrypto/common-hresult-values
+# https://learn.microsoft.com/en-us/windows/win32/learnwin32/error-codes-in-com
+#
+# If you search for the error code using the proper notation,
+# you might be able to find the reference.
+#
+# Don't be overly afraid of `COMError` or `WindowsError`!
+
+
+def signed32bithex_to_int(value: str, /) -> int:
+    """Converts a string in signed 32-bit hexadecimal notation to an integer.
+
+    Examples:
+
+        >>> signed32bithex_to_int('0x00000000') == 0  # S_OK
+        True
+        >>> signed32bithex_to_int('0x00000001') == 1  # S_FALSE
+        True
+        >>> signed32bithex_to_int('0x8000FFFF') == -2147418113  # E_UNEXPECTED
+        True
+    """
+    val = int(value, 16)
+    if val < 0x80000000:
+        return val
+    return val - 0x100000000
+
+
+def int_to_signed32bithex(value: int, /) -> str:
+    """Converts an integer to a string in signed 32-bit hexadecimal notation.
+
+    Examples:
+
+        >>> import comtypes.hresult as hr
+        >>> int_to_signed32bithex(hr.S_OK)
+        '0x00000000'
+        >>> int_to_signed32bithex(hr.S_FALSE)
+        '0x00000001'
+        >>> int_to_signed32bithex(hr.E_UNEXPECTED)
+        '0x8000FFFF'
+
+        >>> from comtypes import CoCreateInstance
+        >>> from comtypes import shelllink, automation
+        >>> CLSID_ShellLink = shelllink.ShellLink().IPersist_GetClassID()
+        >>> p = CoCreateInstance(CLSID_ShellLink)
+        >>> p.QueryInterface(shelllink.IShellLinkA)  # doctest: +ELLIPSIS
+        <POINTER(IShellLinkA) ptr=0x... at ...>
+        >>> p.QueryInterface(automation.IDispatch)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+            ...
+        _ctypes.COMError: (-2147467262, ..., (None, None, None, 0, None))
+        >>> int_to_signed32bithex(-2147467262)  # E_NOINTERFACE
+        '0x80004002'
+    """
+    # it is simpler than using `hex(value & 0xFFFFFFFF)`
+    return f"0x{value & 0xFFFFFFFF:08X}"
+
+
+################################################################

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/messageloop.py

@@ -17,7 +17,7 @@ TranslateMessage = _user32.TranslateMessage
 DispatchMessage = _user32.DispatchMessageA
 
 
-class _MessageLoop(object):
+class _MessageLoop:
     def __init__(self) -> None:
         self._filters: List["_FilterCallable"] = []
 

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/patcher.py

@@ -1,4 +1,4 @@
-class Patch(object):
+class Patch:
     """
     Implements a class decorator suitable for patching an existing class with
     a new namespace.
@@ -69,7 +69,7 @@ def no_replace(f):
     return f
 
 
-class ReferenceEmptyClass(object):
+class ReferenceEmptyClass:
     """
     This empty class will serve as a reference for attributes present on
     any class.

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/persist.py

@@ -12,7 +12,7 @@ interface, useful in client code.
 
 from ctypes import POINTER, Structure, c_int, c_ulong, c_ushort, c_wchar_p
 from ctypes.wintypes import BOOL, DWORD, WORD
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
 from comtypes import COMMETHOD, GUID, HRESULT, IPersist, IUnknown
 from comtypes.automation import VARIANT, tagEXCEPINFO
@@ -65,6 +65,13 @@ class IPropertyBag(IUnknown):
         ),
     ]
 
+    if TYPE_CHECKING:
+
+        def Read(
+            self, pszPropName: str, pVar: VARIANT, pErrorLog: Optional[IErrorLog]
+        ) -> Any: ...
+        def Write(self, pszPropName: str, pVar: Any) -> hints.Hresult: ...
+
 
 class IPersistPropertyBag(IPersist):
     _iid_ = GUID("{37D84F60-42CB-11CE-8135-00AA004BB851}")
@@ -266,7 +273,7 @@ class DictPropertyBag(COMObject):
     _com_interfaces_ = [IPropertyBag]
 
     def __init__(self, **kw):
-        super(DictPropertyBag, self).__init__()
+        super().__init__()
         self.values = kw
 
     def Read(self, this, name, pVar, errorlog):

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/safearray.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 _safearray_type_cache = {}
 
 
-class _SafeArrayAsNdArrayContextManager(object):
+class _SafeArrayAsNdArrayContextManager:
     """Context manager allowing safe arrays to be extracted as ndarrays.
 
     This is thread-safe.
@@ -110,7 +110,7 @@ def _make_safearray_type(itemtype):
             raise TypeError(itemtype)
 
     @Patch(POINTER(sa_type))
-    class _(object):
+    class _:
         # Should explain the ideas how SAFEARRAY is used in comtypes
         _itemtype_ = itemtype  # a ctypes type
         _vartype_ = vartype  # a VARTYPE value: VT_...
@@ -378,7 +378,7 @@ def _make_safearray_type(itemtype):
             return tuple(result)  # for compatibility with pywin32.
 
     @Patch(POINTER(POINTER(sa_type)))
-    class __(object):
+    class __:
         @classmethod
         def from_param(cls, value):
             if isinstance(value, cls._type_):
@@ -398,19 +398,19 @@ def _make_safearray_type(itemtype):
 def _ndarray_to_variant_array(value):
     """Convert an ndarray to VARIANT_dtype array"""
     # Check that variant arrays are supported
-    if comtypes.npsupport.interop.VARIANT_dtype is None:
+    if comtypes.npsupport.VARIANT_dtype is None:
         msg = "VARIANT ndarrays require NumPy 1.7 or newer."
         raise RuntimeError(msg)
-    numpy = comtypes.npsupport.interop.numpy
+    numpy = comtypes.npsupport.numpy
 
     # special cases
-    if numpy.issubdtype(value.dtype, comtypes.npsupport.interop.datetime64):
+    if numpy.issubdtype(value.dtype, comtypes.npsupport.datetime64):
         return _datetime64_ndarray_to_variant_array(value)
 
     from comtypes.automation import VARIANT
 
     # Empty array
-    varr = numpy.zeros(value.shape, comtypes.npsupport.interop.VARIANT_dtype, order="F")
+    varr = numpy.zeros(value.shape, comtypes.npsupport.VARIANT_dtype, order="F")
     # Convert each value to a variant and put it in the array.
     varr.flat = [VARIANT(v) for v in value.flat]
     return varr
@@ -423,12 +423,12 @@ def _datetime64_ndarray_to_variant_array(value):
     # fractional days.
     from comtypes.automation import VT_DATE
 
-    numpy = comtypes.npsupport.interop.numpy
+    numpy = comtypes.npsupport.numpy
     value = numpy.array(value, "datetime64[ns]")
-    value = value - comtypes.npsupport.interop.com_null_date64
+    value = value - comtypes.npsupport.com_null_date64
     # Convert to days
     value = value / numpy.timedelta64(1, "D")
-    varr = numpy.zeros(value.shape, comtypes.npsupport.interop.VARIANT_dtype, order="F")
+    varr = numpy.zeros(value.shape, comtypes.npsupport.VARIANT_dtype, order="F")
     varr["vt"] = VT_DATE
     varr["_"]["VT_R8"].flat = value.flat
     return varr

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/server/__init__.py

@@ -1,14 +1,13 @@
 import ctypes
-from ctypes import HRESULT, POINTER, OleDLL, byref, c_void_p
-from ctypes.wintypes import DWORD, LPVOID
+from ctypes import HRESULT, POINTER, byref
 from typing import TYPE_CHECKING, Any, Optional, Type
 
 import comtypes
 import comtypes.client
 import comtypes.client.dynamic
 from comtypes import GUID, STDMETHOD, IUnknown
+from comtypes import RevokeActiveObject as RevokeActiveObject
 from comtypes.automation import IDispatch
-from comtypes.GUID import REFCLSID
 
 if TYPE_CHECKING:
     from ctypes import _Pointer
@@ -64,41 +63,10 @@ class IClassFactory(IUnknown):
 #         STDMETHOD(HRESULT, "AddConnection", [c_ulong, c_ulong]),
 #         STDMETHOD(HRESULT, "ReleaseConnection", [c_ulong, c_ulong, c_ulong])]
 
-# The following code is untested:
-
-ACTIVEOBJECT_STRONG = 0x0
-ACTIVEOBJECT_WEAK = 0x1
-
-_oleaut32 = OleDLL("oleaut32")
-
-_RegisterActiveObject = _oleaut32.RegisterActiveObject
-_RegisterActiveObject.argtypes = [
-    c_void_p,
-    REFCLSID,
-    DWORD,
-    POINTER(DWORD),
-]
-_RegisterActiveObject.restype = HRESULT
-
-_RevokeActiveObject = _oleaut32.RevokeActiveObject
-_RevokeActiveObject.argtypes = [
-    DWORD,
-    LPVOID,
-]
-_RevokeActiveObject.restype = HRESULT
-
 
 def RegisterActiveObject(comobj: comtypes.COMObject, weak: bool = True) -> int:
+    """Registers a pointer as the active object for its class and returns the handle."""
     punk = comobj._com_pointers_[IUnknown._iid_]
     clsid = comobj._reg_clsid_
-    if weak:
-        flags = ACTIVEOBJECT_WEAK
-    else:
-        flags = ACTIVEOBJECT_STRONG
-    handle = ctypes.c_ulong()
-    _RegisterActiveObject(punk, byref(clsid), flags, byref(handle))
-    return handle.value
-
-
-def RevokeActiveObject(handle: int) -> None:
-    _RevokeActiveObject(handle, None)
+    flags = comtypes.ACTIVEOBJECT_WEAK if weak else comtypes.ACTIVEOBJECT_STRONG
+    return comtypes.RegisterActiveObject(punk, clsid, flags)

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/server/automation.py

@@ -22,7 +22,7 @@ class VARIANTEnumerator(COMObject):
             items  # keep, so that we can restore our iterator (in Reset, and Clone).
         )
         self.seq = iter(self.items)
-        super(VARIANTEnumerator, self).__init__()
+        super().__init__()
 
     def Next(self, this, celt, rgVar, pCeltFetched):
         if not rgVar:
@@ -75,7 +75,7 @@ class COMCollection(COMObject):
     def __init__(self, itemtype, collection):
         self.collection = collection
         self.itemtype = itemtype
-        super(COMCollection, self).__init__()
+        super().__init__()
 
     def _get_Item(self, this, pathname, pitem):
         if not pitem:

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/server/connectionpoints.py

@@ -31,7 +31,7 @@ class ConnectionPointImpl(COMObject):
     def __init__(
         self, sink_interface: Type[IUnknown], sink_typeinfo: ITypeInfo
     ) -> None:
-        super(ConnectionPointImpl, self).__init__()
+        super().__init__()
         self._connections: Dict[int, IUnknown] = {}
         self._cookie = 0
         self._sink_interface = sink_interface
@@ -109,7 +109,7 @@ class ConnectionPointImpl(COMObject):
             yield result
 
 
-class ConnectableObjectMixin(object):
+class ConnectableObjectMixin:
     """Mixin which implements IConnectionPointContainer.
 
     Call Fire_Event(interface, methodname, *args, **kw) to fire an
@@ -122,7 +122,7 @@ class ConnectableObjectMixin(object):
         _reg_typelib_: ClassVar[Tuple[str, int, int]]
 
     def __init__(self) -> None:
-        super(ConnectableObjectMixin, self).__init__()
+        super().__init__()
         self.__connections: Dict[Type[IDispatch], ConnectionPointImpl] = {}
 
         tlib = LoadRegTypeLib(*self._reg_typelib_)

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/server/inprocserver.py

@@ -22,7 +22,7 @@ class ClassFactory(COMObject):
     _com_interfaces_ = [IClassFactory]
 
     def __init__(self, cls: Type[COMObject]) -> None:
-        super(ClassFactory, self).__init__()
+        super().__init__()
         self._cls = cls
 
     def IClassFactory_CreateInstance(
@@ -92,7 +92,7 @@ def _setup_logging(clsid: GUID) -> None:
 
     try:
         hkey = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\Logging" % clsid)
-    except WindowsError:
+    except OSError:
         return
     from comtypes.logutil import NTDebugHandler
 

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/server/localserver.py

@@ -1,11 +1,12 @@
 import logging
 import queue
-from ctypes import HRESULT, POINTER, OleDLL, byref, c_ulong, c_void_p
+from ctypes import HRESULT, OleDLL, byref, c_ulong, c_void_p
 from ctypes.wintypes import DWORD, LPDWORD
 from typing import TYPE_CHECKING, Any, Literal, Optional, Sequence, Type
 
 import comtypes
 from comtypes import GUID, COMObject, IUnknown, hresult
+from comtypes.GUID import REFCLSID
 from comtypes.server import IClassFactory
 
 if TYPE_CHECKING:
@@ -23,7 +24,6 @@ REGCLS_SURROGATE = 8  # must be used when a surrogate process
 
 _ole32 = OleDLL("ole32")
 
-REFCLSID = POINTER(GUID)
 _CoRegisterClassObject = _ole32.CoRegisterClassObject
 _CoRegisterClassObject.argtypes = [REFCLSID, c_void_p, DWORD, DWORD, LPDWORD]
 _CoRegisterClassObject.restype = HRESULT
@@ -45,7 +45,7 @@ class ClassFactory(COMObject):
     regcls: int = REGCLS_MULTIPLEUSE
 
     def __init__(self, cls: Type[COMObject], *args, **kw) -> None:
-        super(ClassFactory, self).__init__()
+        super().__init__()
         self._cls = cls
         self._register_class()
         self._args = args

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/server/register.py

@@ -105,7 +105,7 @@ def _delete_key(hkey: int, subkey: str, *, force: bool) -> None:
         else:
             _debug("DeleteKey %s\\%s", _explain(hkey), subkey)
             winreg.DeleteKey(hkey, subkey)
-    except WindowsError as detail:
+    except OSError as detail:
         if get_winerror(detail) != 2:
             raise
 
@@ -113,7 +113,7 @@ def _delete_key(hkey: int, subkey: str, *, force: bool) -> None:
 _Entry = Tuple[int, str, str, str]
 
 
-class Registrar(object):
+class Registrar:
     """COM class registration.
 
     The COM class can override what this does by implementing
@@ -142,7 +142,7 @@ class Registrar(object):
             _debug('DeleteKey( %s\\CLSID\\%s\\Logging"' % (_explain(HKCR), clsid))
             hkey = winreg.OpenKey(HKCR, rf"CLSID\{clsid}")
             winreg.DeleteKey(hkey, "Logging")
-        except WindowsError as detail:
+        except OSError as detail:
             if get_winerror(detail) != 2:
                 raise
 
@@ -166,7 +166,7 @@ class Registrar(object):
             _debug("DeleteValue(format)")
             try:
                 winreg.DeleteValue(hkey, "format")
-            except WindowsError as detail:
+            except OSError as detail:
                 if get_winerror(detail) != 2:
                     raise
 
@@ -231,7 +231,7 @@ class Registrar(object):
             try:
                 _debug("UnRegisterTypeLib(%s, %s, %s)", *tlib)
                 UnRegisterTypeLib(*tlib)
-            except WindowsError as detail:
+            except OSError as detail:
                 if not get_winerror(detail) in (
                     TYPE_E_REGISTRYACCESS,
                     TYPE_E_CANTLOADLIBRARY,

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_agilent.py

@@ -12,7 +12,7 @@ from comtypes.test import ResourceDenied
 
 try:
     GUID.from_progid("Agilent546XX.Agilent546XX")
-except WindowsError:
+except OSError:
     pass
 
 else:

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_client_dynamic.py

@@ -26,7 +26,7 @@ class Test_Dispatch_Function(ut.TestCase):
 
     def test_returns_dynamic_Dispatch_if_takes_ptrIDispatch_and_raised_winerr(self):
         obj = mock.MagicMock(spec=ctypes.POINTER(automation.IDispatch))
-        obj.GetTypeInfo.side_effect = WindowsError()
+        obj.GetTypeInfo.side_effect = OSError()
         self.assertIsInstance(dynamic.Dispatch(obj), dynamic._Dispatch)
 
     def test_returns_what_is_took_if_takes_other(self):

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_comserver.py

@@ -22,7 +22,7 @@ except ImportError:
 def setUpModule():
     try:
         register(comtypes.test.TestComServer.TestComServer)
-    except WindowsError as e:
+    except OSError as e:
         if e.winerror != 5:  # [Error 5] Access is denied
             raise e
         raise unittest.SkipTest(
@@ -35,7 +35,7 @@ def tearDownModule():
     unregister(comtypes.test.TestComServer.TestComServer)
 
 
-class BaseServerTest(object):
+class BaseServerTest:
     def create_object(self) -> Any: ...
 
     def _find_memleak(self, func):
@@ -116,6 +116,11 @@ class TestInproc(BaseServerTest, unittest.TestCase):
             "TestComServerLib.TestComServer", clsctx=comtypes.CLSCTX_INPROC_SERVER
         )
 
+    @unittest.skip("Fails occasionally with a memory leak on INPROC.")
+    def test_eval(self):
+        # This test sometimes leaks memory when run as an in-process server.
+        pass
+
 
 class TestLocalServer(BaseServerTest, unittest.TestCase):
     def create_object(self):

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_createwrappers.py

@@ -51,7 +51,7 @@ def add_test(fname):
     def test(self):
         try:
             comtypes.typeinfo.LoadTypeLibEx(fname)
-        except WindowsError:
+        except OSError:
             return
         comtypes.client.GetModule(fname)
 

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_dispifc_records.py

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import unittest
 from ctypes import byref, pointer
 

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_dispifc_safearrays.py

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import unittest
 from ctypes import byref, c_double, pointer
 

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_dispinterface.py

@@ -16,7 +16,7 @@ except ImportError:
 def setUpModule():
     try:
         register(comtypes.test.TestDispServer.TestDispServer)
-    except WindowsError as e:
+    except OSError as e:
         if e.winerror != 5:  # [Error 5] Access is denied
             raise e
         raise unittest.SkipTest(

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_excel.py

@@ -1,5 +1,3 @@
-# -*- coding: latin-1 -*-
-
 import datetime
 import sys
 import unittest
@@ -26,7 +24,7 @@ except (ImportError, OSError):
     IMPORT_FAILED = True
 
 
-class BaseBindTest(object):
+class BaseBindTest:
     # `dynamic = True/False` must be defined in subclasses!
     dynamic: ClassVar[bool]
 

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_getactiveobj.py

@@ -1,9 +1,13 @@
+import contextlib
 import time
 import unittest
 
 import comtypes
 import comtypes.client
-import comtypes.test
+
+with contextlib.redirect_stdout(None):  # supress warnings
+    comtypes.client.GetModule("msvidctl.dll")
+from comtypes.gen import MSVidCtlLib as msvidctl
 
 try:
     # pass Word libUUID
@@ -29,7 +33,7 @@ class Test_Word(unittest.TestCase):
     def setUp(self):
         try:
             comtypes.client.GetActiveObject("Word.Application")
-        except WindowsError:
+        except OSError:
             pass
         else:
             # seems word is running, we cannot test this.
@@ -67,5 +71,18 @@ class Test_Word(unittest.TestCase):
             comtypes.client.GetActiveObject("Word.Application")
 
 
+class Test_MSVidCtlLib(unittest.TestCase):
+    def test_register_and_revoke(self):
+        vidctl = comtypes.client.CreateObject(msvidctl.MSVidCtl)
+        with self.assertRaises(WindowsError):
+            comtypes.client.GetActiveObject(msvidctl.MSVidCtl)
+        handle = comtypes.client.RegisterActiveObject(vidctl, msvidctl.MSVidCtl)
+        activeobj = comtypes.client.GetActiveObject(msvidctl.MSVidCtl)
+        self.assertEqual(vidctl, activeobj)
+        comtypes.client.RevokeActiveObject(handle)
+        with self.assertRaises(WindowsError):
+            comtypes.client.GetActiveObject(msvidctl.MSVidCtl)
+
+
 if __name__ == "__main__":
     unittest.main()

{comtypes-1.4.11 → comtypes-1.4.12}/comtypes/test/test_hresult.py

@@ -1,3 +1,4 @@
+import doctest
 import unittest as ut
 
 import comtypes.hresult
@@ -46,3 +47,41 @@ class Test_HRESULT_FROM_WIN32(ut.TestCase):
         ]:
             with self.subTest(w32=w32, hr=hr):
                 self.assertEqual(comtypes.hresult.HRESULT_FROM_WIN32(w32), hr)
+
+
+class Test_signed32bithex_to_int(ut.TestCase):
+    def test(self):
+        for val, expected in [
+            ("0x00000000", comtypes.hresult.S_OK),
+            ("0x00000001", comtypes.hresult.S_FALSE),
+            ("0x8000FFFF", comtypes.hresult.E_UNEXPECTED),
+            ("0x80004002", comtypes.hresult.E_NOINTERFACE),
+            # boundary values
+            ("0x7FFFFFFF", 2147483647),
+            ("0x80000000", -2147483648),
+            ("0xFFFFFFFF", -1),
+        ]:
+            with self.subTest(val=val, expected=expected):
+                self.assertEqual(comtypes.hresult.signed32bithex_to_int(val), expected)
+
+
+class Test_int_to_signed32bithex(ut.TestCase):
+    def test(self):
+        for val, expected in [
+            (comtypes.hresult.S_OK, "0x00000000"),
+            (comtypes.hresult.S_FALSE, "0x00000001"),
+            (comtypes.hresult.E_UNEXPECTED, "0x8000FFFF"),
+            (comtypes.hresult.E_NOINTERFACE, "0x80004002"),
+        ]:
+            with self.subTest(val=val, expected=expected):
+                self.assertEqual(comtypes.hresult.int_to_signed32bithex(val), expected)
+
+
+class DocTest(ut.TestCase):
+    def test(self):
+        doctest.testmod(
+            comtypes.hresult,
+            verbose=False,
+            optionflags=doctest.ELLIPSIS,
+            raise_on_error=True,
+        )