comtypes 1.4.10__zip → 1.4.12__zip

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

@@ -1,10 +1,11 @@
-import ctypes
 import logging
 import sys
 import winreg
+from ctypes import c_void_p, pointer
 from typing import TYPE_CHECKING, Any, Literal, Optional, Type
 
 from comtypes import GUID, COMObject, IUnknown, hresult
+from comtypes._comobject import InprocServer as _InprocRefCounter
 from comtypes.server import IClassFactory
 
 if TYPE_CHECKING:
@@ -21,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(
@@ -29,7 +30,7 @@ class ClassFactory(COMObject):
         this: Any,
         punkOuter: Optional[Type["_Pointer[IUnknown]"]],
         riid: "_Pointer[GUID]",
-        ppv: ctypes.c_void_p,
+        ppv: c_void_p,
     ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         result = self._cls().IUnknown_QueryInterface(None, riid, ppv)
@@ -37,6 +38,7 @@ class ClassFactory(COMObject):
         return result
 
     def IClassFactory_LockServer(self, this: Any, fLock: bool) -> Literal[0]:
+        assert COMObject.__server__ is not None, "The inprocserver is not running yet"
         if fLock:
             COMObject.__server__.Lock()
         else:
@@ -58,7 +60,7 @@ def inproc_find_class(clsid: GUID) -> Type[COMObject]:
     except:
         _debug("NO path to insert")
     else:
-        if not pathdir in sys.path:
+        if pathdir not in sys.path:
             sys.path.insert(0, str(pathdir))
             _debug("insert path %r", pathdir)
         else:
@@ -90,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
 
@@ -138,7 +140,7 @@ def DllGetClassObject(rclsid: int, riid: int, ppv: int) -> int:
             return hresult.CLASS_E_CLASSNOTAVAILABLE
 
         result = ClassFactory(cls).IUnknown_QueryInterface(
-            None, ctypes.pointer(iid), ctypes.c_void_p(ppv)
+            None, pointer(iid), c_void_p(ppv)
         )
         _debug("DllGetClassObject() -> %s", result)
         return result
@@ -149,7 +151,8 @@ def DllGetClassObject(rclsid: int, riid: int, ppv: int) -> int:
 
 def DllCanUnloadNow() -> Literal[1]:  # S_FALSE
     COMObject.__run_inprocserver__()
-    result = COMObject.__server__.DllCanUnloadNow()
+    assert isinstance(COMObject.__server__, _InprocRefCounter)
+    result = COMObject.__server__.DllCanUnloadNow()  # noqa
     # To avoid a memory leak when PyInitialize()/PyUninitialize() are
     # called several times, we refuse to unload the dll.
     return hresult.S_FALSE

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

@@ -1,18 +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, hresult
+from comtypes import GUID, COMObject, IUnknown, hresult
+from comtypes.GUID import REFCLSID
 from comtypes.server import IClassFactory
 
 if TYPE_CHECKING:
@@ -30,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
@@ -40,19 +33,19 @@ _CoRevokeClassObject.argtypes = [DWORD]
 _CoRevokeClassObject.restype = HRESULT
 
 
-def run(classes: Sequence[Type[comtypes.COMObject]]) -> None:
+def run(classes: Sequence[Type[COMObject]]) -> None:
     classobjects = [ClassFactory(cls) for cls in classes]
-    comtypes.COMObject.__run_localserver__(classobjects)
+    COMObject.__run_localserver__(classobjects)
 
 
-class ClassFactory(comtypes.COMObject):
+class ClassFactory(COMObject):
     _com_interfaces_ = [IClassFactory]
     _locks: int = 0
     _queue: Optional[queue.Queue] = None
     regcls: int = REGCLS_MULTIPLEUSE
 
-    def __init__(self, cls: Type[comtypes.COMObject], *args, **kw) -> None:
-        super(ClassFactory, self).__init__()
+    def __init__(self, cls: Type[COMObject], *args, **kw) -> None:
+        super().__init__()
         self._cls = cls
         self._register_class()
         self._args = args
@@ -67,11 +60,11 @@ class ClassFactory(comtypes.COMObject):
     def _register_class(self) -> None:
         regcls = getattr(self._cls, "_regcls_", self.regcls)
         cookie = c_ulong()
-        ptr = self._com_pointers_[comtypes.IUnknown._iid_]
-        clsctx = self._cls._reg_clsctx_
+        ptr = self._com_pointers_[IUnknown._iid_]
+        clsctx = self._cls._reg_clsctx_  # type: ignore
         clsctx &= ~comtypes.CLSCTX_INPROC  # reset the inproc flags
         _CoRegisterClassObject(
-            byref(comtypes.GUID(self._cls._reg_clsid_)),
+            byref(GUID(self._cls._reg_clsid_)),
             ptr,
             clsctx,
             regcls,
@@ -85,8 +78,8 @@ class ClassFactory(comtypes.COMObject):
     def CreateInstance(
         self,
         this: Any,
-        punkOuter: Optional[Type["_Pointer[comtypes.IUnknown]"]],
-        riid: "_Pointer[comtypes.GUID]",
+        punkOuter: Optional[Type["_Pointer[IUnknown]"]],
+        riid: "_Pointer[GUID]",
         ppv: c_void_p,
     ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
@@ -96,8 +89,9 @@ class ClassFactory(comtypes.COMObject):
         return result
 
     def LockServer(self, this: Any, fLock: bool) -> Literal[0]:
+        assert COMObject.__server__ is not None, "The localserver is not running yet"
         if fLock:
-            comtypes.COMObject.__server__.Lock()
+            COMObject.__server__.Lock()
         else:
-            comtypes.COMObject.__server__.Unlock()
+            COMObject.__server__.Unlock()
         return hresult.S_OK

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

@@ -43,7 +43,7 @@ import os
 import sys
 import winreg
 from ctypes import WinDLL, WinError
-from ctypes.wintypes import HKEY, LONG, LPCWSTR
+from ctypes.wintypes import HKEY, LONG, LPCWSTR, MAX_PATH
 from typing import Iterable, Iterator, List, Optional, Tuple, Type, Union
 from winreg import HKEY_CLASSES_ROOT as HKCR
 from winreg import HKEY_CURRENT_USER as HKCU
@@ -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,
@@ -242,7 +242,7 @@ class Registrar(object):
 
 def _get_serverdll(handle: int) -> str:
     """Return the pathname of the dll hosting the COM object."""
-    return GetModuleFileName(handle, 260)
+    return GetModuleFileName(handle, MAX_PATH)
 
 
 class RegistryEntries(abc.ABC):

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/test/test_GUID.py

@@ -30,25 +30,24 @@ class Test(unittest.TestCase):
         )
 
     def test_invalid_constructor_arg(self):
-        self.assertRaises(WindowsError, GUID, "abc")
+        with self.assertRaises(WindowsError):
+            GUID("abc")
 
     def test_from_progid(self):
         self.assertEqual(
             GUID.from_progid("Scripting.FileSystemObject"),
             GUID("{0D43FE01-F093-11CF-8940-00A0C9054228}"),
         )
-        self.assertRaises(WindowsError, GUID.from_progid, "abc")
+        with self.assertRaises(WindowsError):
+            GUID.from_progid("abc")
 
     def test_as_progid(self):
         self.assertEqual(
             GUID("{0D43FE01-F093-11CF-8940-00A0C9054228}").as_progid(),
             "Scripting.FileSystemObject",
         )
-        self.assertRaises(
-            WindowsError,
-            lambda guid: guid.as_progid(),
-            GUID("{00000000-0000-0000-C000-000000000046}"),
-        )
+        with self.assertRaises(WindowsError):
+            GUID("{00000000-0000-0000-C000-000000000046}").as_progid()
 
     def test_create_new(self):
         self.assertNotEqual(GUID.create_new(), GUID.create_new())

{comtypes-1.4.10 → 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.10 → comtypes-1.4.12}/comtypes/test/test_basic.py

@@ -61,7 +61,8 @@ class BasicTest(ut.TestCase):
         self.assertEqual(method_count(IMyInterface), 3)
 
         # assigning _methods_ does not work until we have an _iid_!
-        self.assertRaises(AttributeError, setattr, IMyInterface, "_methods_", [])
+        with self.assertRaises(AttributeError):
+            setattr(IMyInterface, "_methods_", [])
         IMyInterface._iid_ = GUID.create_new()
         IMyInterface._methods_ = []
         self.assertEqual(method_count(IMyInterface), 3)
@@ -96,9 +97,11 @@ class BasicTest(ut.TestCase):
             _iid_ = GUID.create_new()
 
         # We cannot assign _methods_ to IDerived before IBase has it's _methods_:
-        self.assertRaises(TypeError, lambda: setattr(IDerived, "_methods_", []))
+        with self.assertRaises(TypeError):
+            setattr(IDerived, "_methods_", [])
         # Make sure that setting _methods_ failed completely.
-        self.assertRaises(KeyError, lambda: IDerived.__dict__["_methods_"])
+        with self.assertRaises(KeyError):
+            IDerived.__dict__["_methods_"]
         IBase._methods_ = []
         # Now it works:
         IDerived._methods_ = []

{comtypes-1.4.10 → 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.10 → comtypes-1.4.12}/comtypes/test/test_collections.py

@@ -60,7 +60,8 @@ class Test(unittest.TestCase):
 
         # slicing is not (yet?) supported
         cv.Reset()
-        self.assertRaises(ArgumentError, lambda: cv[:])
+        with self.assertRaises(ArgumentError):
+            cv[:]
 
     @unittest.skip("This test takes a long time.  Do we need it? Can it be rewritten?")
     def test_leaks_1(self):
@@ -151,10 +152,12 @@ class TestCollectionInterface(unittest.TestCase):
         self.assertAccessInterface(d)
 
     def test_named_property_no_length(self):
-        self.assertRaises(TypeError, len, self.d.Item)
+        with self.assertRaises(TypeError):
+            len(self.d.Item)
 
     def test_named_property_not_iterable(self):
-        self.assertRaises(TypeError, list, self.d.Item)
+        with self.assertRaises(TypeError):
+            list(self.d.Item)
 
 
 if __name__ == "__main__":

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/test/test_comobject.py

@@ -4,9 +4,10 @@ from ctypes import POINTER, byref, pointer
 from unittest import mock
 
 import comtypes.client
-from comtypes import CLSCTX_SERVER, COMObject, IUnknown, hresult
+from comtypes import CLSCTX_SERVER, COMObject, IPersist, IUnknown, hresult
 from comtypes._post_coinit.misc import _CoCreateInstance
 from comtypes.automation import IDispatch
+from comtypes.typeinfo import GUIDKIND_DEFAULT_SOURCE_DISP_IID
 
 comtypes.client.GetModule("UIAutomationCore.dll")
 comtypes.client.GetModule("scrrun.dll")
@@ -131,11 +132,9 @@ class Test_IProvideClassInfo_GetClassInfo(ut.TestCase):
 
 class Test_IProvideClassInfo2_GetGUID(ut.TestCase):
     def test(self):
-        # GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1
-        self.assertEqual(
-            stdole.StdFont().IProvideClassInfo2_GetGUID(1),
-            stdole.FontEvents._iid_,
-        )
+        obj = stdole.StdFont()
+        actual = obj.IProvideClassInfo2_GetGUID(GUIDKIND_DEFAULT_SOURCE_DISP_IID)
+        self.assertEqual(actual, stdole.FontEvents._iid_)
 
 
 class Test_IPersist_GetClassID(ut.TestCase):
@@ -144,3 +143,17 @@ class Test_IPersist_GetClassID(ut.TestCase):
             uiac.CUIAutomation().IPersist_GetClassID(),
             uiac.CUIAutomation._reg_clsid_,
         )
+
+
+class Test_Vtbl(ut.TestCase):
+    def test_com_pointers(self):
+        stdpic = stdole.StdPicture()
+        cuia = uiac.CUIAutomation()
+        self.assertIs(
+            type(stdpic._com_pointers_[IPersist._iid_]),
+            type(cuia._com_pointers_[IPersist._iid_]),
+        )
+        self.assertIn(IDispatch._iid_, stdpic._com_pointers_)
+        self.assertNotIn(IDispatch._iid_, cuia._com_pointers_)
+        self.assertIn(stdole.IPictureDisp._iid_, stdpic._com_pointers_)
+        self.assertIn(uiac.IUIAutomation._iid_, cuia._com_pointers_)

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

@@ -5,7 +5,7 @@ from typing import Any
 
 import comtypes.server
 import comtypes.test.TestComServer
-from comtypes import BSTR
+from comtypes import BSTR, errorinfo, hresult, shelllink
 from comtypes.automation import VARIANT, _midlSAFEARRAY
 from comtypes.client import CreateObject, GetActiveObject
 from comtypes.server.register import register, unregister
@@ -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):
@@ -201,6 +206,26 @@ class ActiveObjTest(unittest.TestCase):
         self._doit(weak=False)
 
 
+class SupportErrorInfoTest(unittest.TestCase):
+    def create_object(self):
+        return CreateObject(
+            comtypes.test.TestComServer.TestComServer,
+            interface=comtypes.test.TestComServer.ITestComServer,
+        )
+
+    def test_returns_S_OK(self):
+        psei = self.create_object().QueryInterface(errorinfo.ISupportErrorInfo)
+        iid = comtypes.test.TestComServer.ITestComServer._iid_
+        hr = psei.InterfaceSupportsErrorInfo(iid)
+        self.assertEqual(hr, hresult.S_OK)
+
+    def test_returns_S_FALSE(self):
+        psei = self.create_object().QueryInterface(errorinfo.ISupportErrorInfo)
+        iid = shelllink.IShellLinkW._iid_
+        hr = psei.InterfaceSupportsErrorInfo(iid)
+        self.assertEqual(hr, hresult.S_FALSE)
+
+
 class VariantTest(unittest.TestCase):
     def test_UDT(self):
         from comtypes.gen.TestComServerLib import MYCOLOR
@@ -277,7 +302,10 @@ class TestEvents(unittest.TestCase):
         import comtypes.test.test_comserver
 
         doctest.testmod(
-            comtypes.test.test_comserver, verbose=False, optionflags=doctest.ELLIPSIS
+            comtypes.test.test_comserver,
+            verbose=False,
+            optionflags=doctest.ELLIPSIS,
+            raise_on_error=True,
         )
 
 

{comtypes-1.4.10 → 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.10 → comtypes-1.4.12}/comtypes/test/test_dict.py

@@ -14,7 +14,8 @@ class Test(unittest.TestCase):
 
         # Count is a normal propget, no propput
         self.assertEqual(d.Count, 0)
-        self.assertRaises(AttributeError, lambda: setattr(d, "Count", -1))
+        with self.assertRaises(AttributeError):
+            setattr(d, "Count", -1)
 
         # HashVal is a 'named' propget, no propput
         ##d.HashVal

{comtypes-1.4.10 → 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.10 → 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.10 → 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.10 → comtypes-1.4.12}/comtypes/test/test_dyndispatch.py

@@ -66,10 +66,12 @@ class Test(unittest.TestCase):
         self.assertEqual(d3.Item["baz"], 3.14)
 
     def test_named_property_no_length(self):
-        self.assertRaises(TypeError, len, self.d.Item)
+        with self.assertRaises(TypeError):
+            len(self.d.Item)
 
     def test_named_property_not_iterable(self):
-        self.assertRaises(TypeError, list, self.d.Item)
+        with self.assertRaises(TypeError):
+            list(self.d.Item)
 
     def assertAccessInterface(self, d):
         """Asserts access via indexing and named property"""

comtypes-1.4.12/comtypes/test/test_errorinfo.py

@@ -0,0 +1,115 @@
+import unittest as ut
+
+from comtypes import errorinfo, shelllink
+from comtypes import hresult as hres
+
+
+class Test_GetErrorInfo(ut.TestCase):
+    def test_error_has_been_set(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        errmsg = "sample unexpected error message for tests"
+        errcode = hres.E_UNEXPECTED
+        helpcontext = 123
+        hr = errorinfo.ReportError(
+            errmsg,
+            shelllink.IShellLinkW._iid_,
+            str(shelllink.ShellLink._reg_clsid_),
+            helpfile="help.chm",
+            helpcontext=helpcontext,
+            hresult=errcode,
+        )
+        self.assertEqual(errcode, hr)
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNotNone(pei)
+        assert pei is not None  # for static type guard
+        self.assertEqual(shelllink.IShellLinkW._iid_, pei.GetGUID())
+        self.assertEqual("lnkfile", pei.GetSource())
+        self.assertEqual(errmsg, pei.GetDescription())
+        self.assertEqual("help.chm", pei.GetHelpFile())
+        self.assertEqual(helpcontext, pei.GetHelpContext())
+        # Calling `GetErrorInfo` clears the error state for the thread.
+        # Therefore, `None` is returned in the second call.
+        self.assertIsNone(errorinfo.GetErrorInfo())
+
+    def test_without_optional_args(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        errmsg = "sample unexpected error message for tests"
+        hr = errorinfo.ReportError(errmsg, shelllink.IShellLinkW._iid_)
+        self.assertEqual(hres.DISP_E_EXCEPTION, hr)
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNotNone(pei)
+        assert pei is not None  # for static type guard
+        self.assertEqual(shelllink.IShellLinkW._iid_, pei.GetGUID())
+        self.assertIsNone(pei.GetSource())
+        self.assertEqual(errmsg, pei.GetDescription())
+        self.assertIsNone(pei.GetHelpFile())
+        self.assertEqual(0, pei.GetHelpContext())
+
+    def test_error_has_not_been_set(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNone(pei)
+
+
+def raise_runtime_error():
+    _raise_runtime_error()
+
+
+def _raise_runtime_error():
+    raise RuntimeError("for testing")
+
+
+class Test_ReportException(ut.TestCase):
+    def test_without_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        iid = shelllink.IShellLinkW._iid_
+        try:
+            raise_runtime_error()
+        except RuntimeError:
+            hr = errorinfo.ReportException(hres.E_UNEXPECTED, iid)
+        self.assertEqual(hres.E_UNEXPECTED, hr)
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNotNone(pei)
+        assert pei is not None  # for static type guard
+        self.assertEqual(shelllink.IShellLinkW._iid_, pei.GetGUID())
+        self.assertIsNone(pei.GetSource())
+        self.assertEqual("<class 'RuntimeError'>: for testing", pei.GetDescription())
+        self.assertIsNone(pei.GetHelpFile())
+        self.assertEqual(0, pei.GetHelpContext())
+        self.assertIsNone(errorinfo.GetErrorInfo())
+
+    def test_with_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        stem = "<class 'RuntimeError'>: for testing"
+        iid = shelllink.IShellLinkW._iid_
+        for slv, text in [
+            # XXX: If the codebase changes, the line where functions or
+            # methods are defined will change, meaning this test is brittle.
+            (0, f"{stem} ({__name__}, line 96)"),
+            (1, f"{stem} ({__name__}, line 55)"),
+            (2, f"{stem} ({__name__}, line 59)"),
+        ]:
+            with self.subTest(text=text):
+                try:
+                    raise_runtime_error()
+                except RuntimeError:
+                    errorinfo.ReportException(hres.E_UNEXPECTED, iid, stacklevel=slv)
+                pei = errorinfo.GetErrorInfo()
+                assert pei is not None  # for static type guard
+                self.assertEqual(text, pei.GetDescription())
+                self.assertIsNone(errorinfo.GetErrorInfo())
+
+    def test_with_over_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        iid = shelllink.IShellLinkW._iid_
+        try:
+            raise_runtime_error()
+        except RuntimeError:
+            with self.assertRaises(ValueError):
+                errorinfo.ReportException(hres.E_UNEXPECTED, iid, stacklevel=4)
+
+    def test_with_no_error_and_zero_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        iid = shelllink.IShellLinkW._iid_
+        with self.assertRaises(ValueError):
+            errorinfo.ReportException(hres.E_UNEXPECTED, iid, stacklevel=0)

{comtypes-1.4.10 → 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]