comtypes 1.4.9__zip → 1.4.11__zip

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/test_BSTR.py

@@ -1,5 +1,6 @@
 import unittest
-from ctypes import WINFUNCTYPE, c_uint, c_void_p, oledll, windll
+from ctypes import WinDLL
+from ctypes.wintypes import UINT
 
 from comtypes import BSTR
 from comtypes.test.find_memleak import find_memleak
@@ -24,23 +25,12 @@ class Test(unittest.TestCase):
 
         self.check_leaks(doit)
 
-    def test_paramflags(self):
-        prototype = WINFUNCTYPE(c_void_p, BSTR)
-        func = prototype(("SysStringLen", oledll.oleaut32))
-        func.restype = c_void_p
-        func.argtypes = (BSTR,)
-
-        def doit():
-            func("abcdef")
-            func("abc xyz")
-            func(BSTR("abc def"))
-
-        self.check_leaks(doit)
-
     def test_inargs(self):
-        SysStringLen = windll.oleaut32.SysStringLen
-        SysStringLen.argtypes = (BSTR,)
-        SysStringLen.restype = c_uint
+        oleaut32 = WinDLL("oleaut32")
+
+        SysStringLen = oleaut32.SysStringLen
+        SysStringLen.argtypes = [BSTR]
+        SysStringLen.restype = UINT
 
         self.assertEqual(SysStringLen("abc xyz"), 7)
 

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/test_GUID.py

@@ -1,4 +1,5 @@
 import unittest
+
 from comtypes import GUID
 
 
@@ -29,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.9 → comtypes-1.4.11}/comtypes/test/test_QueryService.py

@@ -1,5 +1,6 @@
 import unittest
 from ctypes import POINTER
+
 import comtypes
 from comtypes.client import CreateObject, GetModule
 

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

@@ -3,11 +3,12 @@
 # connected, the driver is used in simulation mode.
 
 import unittest
-from comtypes.test import ResourceDenied
-from comtypes.client import CreateObject
+from ctypes import POINTER, c_double
+
 from comtypes import GUID
+from comtypes.client import CreateObject
 from comtypes.safearray import _midlSAFEARRAY
-from ctypes import c_double, POINTER
+from comtypes.test import ResourceDenied
 
 try:
     GUID.from_progid("Agilent546XX.Agilent546XX")

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/test_basic.py

@@ -1,7 +1,9 @@
 ##import ut
 import unittest as ut
-from ctypes import windll, POINTER, byref, HRESULT
-from comtypes import IUnknown, STDMETHOD, GUID
+from ctypes import HRESULT, POINTER, byref
+
+from comtypes import GUID, STDMETHOD, IUnknown
+from comtypes.typeinfo import ICreateTypeLib2, _CreateTypeLib2
 
 # XXX leaks references!
 
@@ -20,8 +22,10 @@ class BasicTest(ut.TestCase):
         POINTER(IUnknown)()
 
     def test_refcounts(self):
-        p = POINTER(IUnknown)()
-        windll.oleaut32.CreateTypeLib2(1, "blabla", byref(p))
+        # Since all COM interfaces derive from IUnknown and have the same reference counting behavior, any interface
+        # — whether ICreateTypeLib2 or otherwise — could be used for this test.
+        p = POINTER(ICreateTypeLib2)()
+        _CreateTypeLib2(1, "blabla", byref(p))
         # initial refcount is 2
         for i in range(2, 10):
             self.assertEqual(p.AddRef(), i)
@@ -29,8 +33,10 @@ class BasicTest(ut.TestCase):
             self.assertEqual(p.Release(), i)
 
     def test_qi(self):
-        p = POINTER(IUnknown)()
-        windll.oleaut32.CreateTypeLib2(1, "blabla", byref(p))
+        # Since all COM interfaces derive from IUnknown and have the same QueryInterface behavior, any interface
+        # — whether ICreateTypeLib2 or otherwise — could be used for this test.
+        p = POINTER(ICreateTypeLib2)()
+        _CreateTypeLib2(1, "blabla", byref(p))
         self.assertEqual(p.AddRef(), 2)
         self.assertEqual(p.Release(), 1)
 
@@ -55,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)
@@ -90,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.9 → comtypes-1.4.11}/comtypes/test/test_clear_cache.py

@@ -4,8 +4,8 @@ Test for the ``comtypes.clear_cache`` module.
 
 import contextlib
 import runpy
-from unittest.mock import patch, call
 from unittest import TestCase
+from unittest.mock import call, patch
 
 from comtypes.client import _find_gen_dir
 

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/test_client.py

@@ -1,11 +1,11 @@
 import contextlib
-from ctypes import POINTER, byref
 import os
 import sys
 import unittest as ut
+from ctypes import POINTER, byref
 
 import comtypes.client
-from comtypes import COSERVERINFO, CLSCTX_INPROC_SERVER
+from comtypes import CLSCTX_INPROC_SERVER, COSERVERINFO
 
 # create the typelib wrapper and import it
 comtypes.client.GetModule("scrrun.dll")

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

@@ -2,8 +2,8 @@ import ctypes
 import unittest as ut
 from unittest import mock
 
-from comtypes import automation, COMError, IUnknown
-from comtypes.client import CreateObject, dynamic, GetModule, lazybind
+from comtypes import COMError, IUnknown, automation
+from comtypes.client import CreateObject, GetModule, dynamic, lazybind
 
 
 class Test_Dispatch_Function(ut.TestCase):

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/test_client_regenerate_modules.py

@@ -1,12 +1,12 @@
 import contextlib
 import importlib
-from pathlib import Path
 import shutil
 import sys
 import tempfile
 import types
-from typing import Iterator
 import unittest as ut
+from pathlib import Path
+from typing import Iterator
 from unittest import mock
 
 import comtypes

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/test_collections.py

@@ -1,7 +1,7 @@
 import unittest
-from comtypes.client import CreateObject
 from ctypes import ArgumentError
 
+from comtypes.client import CreateObject
 from comtypes.test.find_memleak import find_memleak
 
 
@@ -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.9 → comtypes-1.4.11}/comtypes/test/test_comobject.py

@@ -3,10 +3,11 @@ import unittest as ut
 from ctypes import POINTER, byref, pointer
 from unittest import mock
 
-import comtypes
 import comtypes.client
-from comtypes import 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")
@@ -54,10 +55,10 @@ class Test_IUnknown_QueryInterface(ut.TestCase):
 
     def test_valid_pointer(self):
         ptr = ctypes.c_void_p()
-        ctypes.oledll.ole32.CoCreateInstance(
+        _CoCreateInstance(
             byref(scrrun.Dictionary._reg_clsid_),
             None,
-            comtypes.CLSCTX_SERVER,
+            CLSCTX_SERVER,
             byref(scrrun.IDictionary._iid_),
             byref(ptr),
         )
@@ -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.9 → comtypes-1.4.11}/comtypes/test/test_comserver.py

@@ -3,10 +3,11 @@ import unittest
 from ctypes import pointer
 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
+from comtypes.client import CreateObject, GetActiveObject
 from comtypes.server.register import register, unregister
 from comtypes.test.find_memleak import find_memleak
 
@@ -171,6 +172,55 @@ class TestLocalServer_win32com(BaseServerTest, unittest.TestCase):
         pass
 
 
+class ActiveObjTest(unittest.TestCase):
+    def get_active_object(self) -> comtypes.test.TestComServer.ITestComServer:
+        return GetActiveObject(
+            comtypes.test.TestComServer.TestComServer,
+            interface=comtypes.test.TestComServer.ITestComServer,
+        )
+
+    def _doit(self, weak: bool):
+        comobj = comtypes.test.TestComServer.TestComServer()
+        with self.assertRaises(OSError):
+            self.get_active_object()
+        handle = comtypes.server.RegisterActiveObject(comobj, weak=weak)
+        activeobj = self.get_active_object()
+        self.assertEqual(activeobj.MixedInOut(2, 4), (3, 5))
+        self.assertEqual(activeobj.AddRef(), 3)
+        self.assertEqual(activeobj.Release(), 2)
+        punk = comobj.QueryInterface(comtypes.test.TestComServer.ITestComServer)
+        self.assertEqual(activeobj, punk)
+        comtypes.server.RevokeActiveObject(handle)
+        with self.assertRaises(OSError):
+            self.get_active_object()
+
+    def test_activeobj_weak_registration(self):
+        self._doit(weak=True)
+
+    def test_activeobj_strong_registration(self):
+        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
@@ -247,7 +297,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.9 → comtypes-1.4.11}/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.9 → comtypes-1.4.11}/comtypes/test/test_dispifc_records.py

@@ -1,10 +1,10 @@
 # coding: utf-8
 
 import unittest
+from ctypes import byref, pointer
 
 from comtypes import CLSCTX_LOCAL_SERVER
 from comtypes.client import CreateObject, GetModule
-from ctypes import byref, pointer
 
 ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
 

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

@@ -1,7 +1,7 @@
 # coding: utf-8
 
-from ctypes import byref, c_double, pointer
 import unittest
+from ctypes import byref, c_double, pointer
 
 import comtypes
 import comtypes.safearray

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/test_dyndispatch.py

@@ -1,4 +1,5 @@
 import unittest
+
 from comtypes.automation import IDispatch
 from comtypes.client import CreateObject, GetModule
 from comtypes.client.lazybind import Dispatch
@@ -65,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.11/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.9 → comtypes-1.4.11}/comtypes/test/test_findgendir.py

@@ -4,15 +4,14 @@ import os
 import sys
 import tempfile
 import types
-from typing import Iterator
 import unittest
+from typing import Iterator
 from unittest import mock
 
 import comtypes
 import comtypes.client
 import comtypes.gen
 
-
 IMGBASE = os.path.splitext(os.path.basename(sys.executable))[0]
 
 

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

@@ -8,9 +8,9 @@ import comtypes.test
 try:
     # pass Word libUUID
     comtypes.client.GetModule(("{00020905-0000-0000-C000-000000000046}",))
-    IMPORT_FAILED = False
+    IMPORT_WORD_FAILED = False
 except (ImportError, OSError):
-    IMPORT_FAILED = True
+    IMPORT_WORD_FAILED = True
 
 
 ################################################################
@@ -24,8 +24,8 @@ except (ImportError, OSError):
 ################################################################
 
 
-@unittest.skipIf(IMPORT_FAILED, "This depends on Word.")
-class Test(unittest.TestCase):
+@unittest.skipIf(IMPORT_WORD_FAILED, "This depends on Word.")
+class Test_Word(unittest.TestCase):
     def setUp(self):
         try:
             comtypes.client.GetActiveObject("Word.Application")

comtypes-1.4.11/comtypes/test/test_hresult.py

@@ -0,0 +1,48 @@
+import unittest as ut
+
+import comtypes.hresult
+
+
+class Test_MAKE_HRESULT(ut.TestCase):
+    def test(self):
+        for sev, fac, code, hr in [
+            (0x0000, 0x0000, 0x0000, 0),
+            (0x0001, 0x0000, 0x0000, -2147483648),
+            (0x0000, 0x0001, 0x0000, 65536),
+            (0x0000, 0x0000, 0x0001, 1),
+            (0x0001, 0xFFFF, 0xFFFF, -1),
+            (0x0000, 0xFFFF, 0xFFFF, -1),
+            (0x0001, 0x0000, 0x0001, -2147483647),
+            (0x0001, 0x0001, 0x0001, -2147418111),
+            (0x0000, 0x0001, 0xFFFF, 131071),
+            (0x0001, 0xFFFF, 0x0000, -65536),
+            (0x0001, 0x0000, 0xFFFF, -2147418113),
+        ]:
+            with self.subTest(sev=sev, fac=fac, code=code, hr=hr):
+                self.assertEqual(comtypes.hresult.MAKE_HRESULT(sev, fac, code), hr)
+
+
+ERROR_OUTOFMEMORY = 14  # 0xE
+ERROR_INVALID_PARAMETER = 87  # 0x57
+RPC_S_SERVER_UNAVAILABLE = 1722  # 0x6BA
+
+
+class Test_HRESULT_FROM_WIN32(ut.TestCase):
+    def test(self):
+        for w32, hr in [
+            (ERROR_OUTOFMEMORY, comtypes.hresult.E_OUTOFMEMORY),
+            (ERROR_INVALID_PARAMETER, comtypes.hresult.E_INVALIDARG),
+            (RPC_S_SERVER_UNAVAILABLE, comtypes.hresult.RPC_S_SERVER_UNAVAILABLE),
+            (-1, -1),
+            (0, -2147024896),
+            (1, -2147024895),
+            (0xFFFF - 3, -2146959364),
+            (0xFFFF - 2, -2146959363),
+            (0xFFFF - 1, -2146959362),
+            (0xFFFF + 0, -2146959361),
+            (0xFFFF + 1, -2147024896),
+            (0xFFFF + 2, -2147024895),
+            (0xFFFF + 3, -2147024894),
+        ]:
+            with self.subTest(w32=w32, hr=hr):
+                self.assertEqual(comtypes.hresult.HRESULT_FROM_WIN32(w32), hr)