comtypes 1.4.9__zip → 1.4.11__zip

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

@@ -1,26 +1,80 @@
 import _ctypes
-import ctypes
 import os
 import sys
 import unittest as ut
 import winreg
+from ctypes.wintypes import MAX_PATH
 from unittest import mock
 
 import comtypes
 import comtypes.server.inprocserver
 from comtypes import GUID
 from comtypes.server import register
-from comtypes.server.register import Registrar, RegistryEntries, _get_serverdll
+from comtypes.server.register import (
+    FrozenRegistryEntries,
+    InterpRegistryEntries,
+    Registrar,
+    _delete_key,
+    _get_serverdll,
+)
 
 HKCR = winreg.HKEY_CLASSES_ROOT
 MULTI_SZ = winreg.REG_MULTI_SZ
 SZ = winreg.REG_SZ
 
+ERROR_ACCESS_DENIED = 5
+ERROR_FILE_NOT_FOUND = 2
 
+
+@mock.patch.object(register, "SHDeleteKey")
+@mock.patch.object(register, "winreg")
+class Test_delete_key(ut.TestCase):
+    def test_calls_sh_deletekey_if_forced(self, _winreg, _sh_deletekey):
+        _delete_key(123, "subkey", force=True)
+        _winreg.DeleteKey.assert_not_called()
+        _sh_deletekey.assert_called_once_with(123, "subkey")
+
+    def test_calls_winreg_deletekey_if_not_forced(self, _winreg, _sh_deletekey):
+        _delete_key(123, "subkey", force=False)
+        _winreg.DeleteKey.assert_called_once_with(123, "subkey")
+        _sh_deletekey.assert_not_called()
+
+    def test_ignores_error_on_sh_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
+        _sh_deletekey.side_effect = err
+        _delete_key(123, "subkey", force=True)
+        _winreg.DeleteKey.assert_not_called()
+        _sh_deletekey.assert_called_once_with(123, "subkey")
+
+    def test_ignores_error_on_winreg_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
+        _winreg.DeleteKey.side_effect = err
+        _delete_key(123, "subkey", force=False)
+        _winreg.DeleteKey.assert_called_once_with(123, "subkey")
+        _sh_deletekey.assert_not_called()
+
+    def test_not_ignores_winerror_on_sh_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
+        _sh_deletekey.side_effect = err
+        with self.assertRaises(OSError) as e:
+            _delete_key(123, "subkey", force=True)
+        self.assertEqual(e.exception.winerror, ERROR_ACCESS_DENIED)
+        _winreg.DeleteKey.assert_not_called()
+        _sh_deletekey.assert_called_once_with(123, "subkey")
+
+    def test_not_ignores_winerror_on_winreg_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
+        _winreg.DeleteKey.side_effect = err
+        with self.assertRaises(OSError) as e:
+            _delete_key(123, "subkey", force=False)
+        self.assertEqual(e.exception.winerror, ERROR_ACCESS_DENIED)
+        _winreg.DeleteKey.assert_called_once_with(123, "subkey")
+        _sh_deletekey.assert_not_called()
+
+
+@mock.patch.object(register, "winreg")
 class Test_Registrar_nodebug(ut.TestCase):
-    @mock.patch.object(register, "winreg")
     def test_calls_openkey_and_deletekey(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.OpenKey.return_value = hkey
         reg_clsid = GUID.create_new()
@@ -33,10 +87,7 @@ class Test_Registrar_nodebug(ut.TestCase):
         _winreg.OpenKey.assert_called_once_with(HKCR, rf"CLSID\{reg_clsid}")
         _winreg.DeleteKey.assert_called_once_with(hkey, "Logging")
 
-    @mock.patch.object(register, "winreg")
     def test_ignores_winerror(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
-        ERROR_FILE_NOT_FOUND = 2
         err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
         _winreg.OpenKey.side_effect = err
         reg_clsid = GUID.create_new()
@@ -49,12 +100,9 @@ class Test_Registrar_nodebug(ut.TestCase):
         _winreg.OpenKey.assert_called_once_with(HKCR, rf"CLSID\{reg_clsid}")
         _winreg.DeleteKey.assert_not_called()
 
-    @mock.patch.object(register, "winreg")
     def test_not_ignores_winerror(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.OpenKey.return_value = hkey
-        ERROR_ACCESS_DENIED = 5
         err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
         _winreg.OpenKey.return_value = hkey
         _winreg.DeleteKey.side_effect = err
@@ -71,10 +119,9 @@ class Test_Registrar_nodebug(ut.TestCase):
         _winreg.DeleteKey.assert_called_once_with(hkey, "Logging")
 
 
+@mock.patch.object(register, "winreg")
 class Test_Registrar_debug(ut.TestCase):
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_sets_format(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         _winreg.REG_SZ = SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
@@ -97,9 +144,7 @@ class Test_Registrar_debug(ut.TestCase):
             ],
         )
 
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_deletes_format(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.CreateKey.return_value = hkey
@@ -117,13 +162,10 @@ class Test_Registrar_debug(ut.TestCase):
         )
         _winreg.DeleteValue.assert_called_once_with(hkey, "format")
 
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_ignores_errors_on_deleting(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.CreateKey.return_value = hkey
-        ERROR_FILE_NOT_FOUND = 2
         err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
         _winreg.DeleteValue.side_effect = err
         levels = ["lv=DEBUG"]
@@ -140,13 +182,10 @@ class Test_Registrar_debug(ut.TestCase):
         )
         _winreg.DeleteValue.assert_called_once_with(hkey, "format")
 
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_not_ignores_errors_on_deleting(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.CreateKey.return_value = hkey
-        ERROR_ACCESS_DENIED = 5
         err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
         _winreg.DeleteValue.side_effect = err
         levels = ["lv=DEBUG"]
@@ -191,24 +230,17 @@ class Test_Registrar_unregister(ut.TestCase):
 
 
 class Test_get_serverdll(ut.TestCase):
-    def test_nonfrozen(self):
-        self.assertEqual(_ctypes.__file__, _get_serverdll())
-
-    def test_frozen(self):
-        with mock.patch.object(register, "sys") as _sys:
-            with mock.patch.object(register, "windll") as _windll:
-                handle = 1234
-                _sys.frozendllhandle = handle
-                self.assertEqual(b"\x00" * 260, _get_serverdll())
-                GetModuleFileName = _windll.kernel32.GetModuleFileNameA
-                (((hModule, lpFilename, nSize), _),) = GetModuleFileName.call_args_list
-                self.assertEqual(handle, hModule)
-                buf_type = type(ctypes.create_string_buffer(260))
-                self.assertIsInstance(lpFilename, buf_type)
-                self.assertEqual(260, nSize)
-
-
-class Test_NonFrozen_RegistryEntries(ut.TestCase):
+    @mock.patch.object(register, "GetModuleFileName")
+    def test_frozen(self, GetModuleFileName):
+        handle, dll_path = 1234, r"path\to\frozen.dll"
+        GetModuleFileName.return_value = dll_path
+        self.assertEqual(dll_path, _get_serverdll(handle))
+        (((hmodule, maxsize), _),) = GetModuleFileName.call_args_list
+        self.assertEqual(handle, hmodule)
+        self.assertEqual(MAX_PATH, maxsize)
+
+
+class Test_InterpRegistryEntries(ut.TestCase):
     def test_reg_clsid(self):
         reg_clsid = GUID.create_new()
 
@@ -216,7 +248,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             _reg_clsid_ = reg_clsid
 
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_desc(self):
         reg_clsid = GUID.create_new()
@@ -227,7 +259,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             _reg_desc_ = reg_desc
 
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", reg_desc)]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_novers_progid(self):
         reg_clsid = GUID.create_new()
@@ -238,7 +270,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             _reg_novers_progid_ = reg_novers_progid
 
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "Lib Server")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_progid(self):
         reg_clsid = GUID.create_new()
@@ -254,7 +286,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, reg_progid, "", "Lib Server 1"),
             (HKCR, rf"{reg_progid}\CLSID", "", str(reg_clsid)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_progid_reg_desc(self):
         reg_clsid = GUID.create_new()
@@ -272,7 +304,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, reg_progid, "", "description for testing"),
             (HKCR, rf"{reg_progid}\CLSID", "", str(reg_clsid)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_progid_reg_novers_progid(self):
         reg_clsid = GUID.create_new()
@@ -295,7 +327,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, rf"{reg_novers_progid}\CurVer", "", "Lib.Server.1"),
             (HKCR, rf"{reg_novers_progid}\CLSID", "", str(reg_clsid)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_local_server(self):
         reg_clsid = GUID.create_new()
@@ -311,7 +343,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, clsid_sub, "", ""),
             (HKCR, local_srv_sub, "", f"{sys.executable} {__file__}"),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_inproc_server(self):
         reg_clsid = GUID.create_new()
@@ -330,7 +362,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, inproc_srv_sub, "PythonClass", full_classname),
             (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_inproc_server_reg_threading(self):
         reg_clsid = GUID.create_new()
@@ -352,7 +384,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
             (HKCR, inproc_srv_sub, "ThreadingModel", reg_threading),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_typelib(self):
         reg_clsid = GUID.create_new()
@@ -367,7 +399,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, rf"CLSID\{reg_clsid}", "", ""),
             (HKCR, rf"CLSID\{reg_clsid}\Typelib", "", libid),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_all_entries(self):
         reg_clsid = GUID.create_new()
@@ -408,34 +440,17 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, inproc_srv_sub, "ThreadingModel", reg_threading),
             (HKCR, rf"{clsid_sub}\Typelib", "", libid),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
 
-class Test_Frozen_RegistryEntries(ut.TestCase):
-    @mock.patch.object(register, "sys")
-    def test_local_dll(self, _sys):
-        _sys.mock_add_spec(["executable", "frozen"])
-        _sys.executable = sys.executable
-        _sys.frozen = "dll"
-        reg_clsid = GUID.create_new()
-        reg_clsctx = comtypes.CLSCTX_LOCAL_SERVER
+class Test_FrozenRegistryEntries(ut.TestCase):
+    SERVERDLL = r"my\target\server.dll"
 
-        class Cls:
-            _reg_clsid_ = reg_clsid
-            _reg_clsctx_ = reg_clsctx
-
-        clsid_sub = rf"CLSID\{reg_clsid}"
-        expected = [
-            (HKCR, clsid_sub, "", ""),
-            (HKCR, rf"{clsid_sub}\LocalServer32", "", sys.executable),
-        ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+    # We do not test the scenario where `frozen` is `'dll'` but
+    # `frozendllhandle` is `None`, as it is not a situation
+    # we anticipate.
 
-    @mock.patch.object(register, "sys")
-    def test_local_frozendllhandle(self, _sys):
-        _sys.mock_add_spec(["frozen", "frozendllhandle"])
-        _sys.frozen = "dll"
-        _sys.frozendllhandle = 1234
+    def test_local_dll(self):
         reg_clsid = GUID.create_new()
         reg_clsctx = comtypes.CLSCTX_LOCAL_SERVER
 
@@ -443,53 +458,30 @@ class Test_Frozen_RegistryEntries(ut.TestCase):
             _reg_clsid_ = reg_clsid
             _reg_clsctx_ = reg_clsctx
 
+        # In such cases, the server does not start because the
+        # InprocServer32/LocalServer32 keys are not registered.
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        entries = FrozenRegistryEntries(Cls, frozen="dll", frozendllhandle=1234)
+        self.assertEqual(expected, list(entries))
 
-    @mock.patch.object(register, "sys")
-    def test_inproc_windows_exe(self, _sys):
-        _sys.mock_add_spec(["frozen"])
-        _sys.frozen = "windows_exe"
+    def test_local_windows_exe(self):
         reg_clsid = GUID.create_new()
-        reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
-
-        class Cls:
-            _reg_clsid_ = reg_clsid
-            _reg_clsctx_ = reg_clsctx
-
-        expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
-
-    @mock.patch.object(register, "_get_serverdll", lambda: r"my\target\server.dll")
-    @mock.patch.object(register, "sys")
-    def test_inproc_dll_frozendllhandle_clsid_to_class(self, _sys):
-        _sys.mock_add_spec(["frozen", "frozendllhandle"])
-        _sys.frozen = "dll"
-        _sys.frozendllhandle = 1234
-        reg_clsid = GUID.create_new()
-        reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
+        reg_clsctx = comtypes.CLSCTX_LOCAL_SERVER
 
         class Cls:
             _reg_clsid_ = reg_clsid
             _reg_clsctx_ = reg_clsctx
 
-        clsid_sub = rf"CLSID\{reg_clsid}"
-        inproc_srv_sub = rf"{clsid_sub}\InprocServer32"
         expected = [
-            (HKCR, clsid_sub, "", ""),
-            (HKCR, inproc_srv_sub, "", r"my\target\server.dll"),
+            (HKCR, rf"CLSID\{reg_clsid}", "", ""),
+            (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", sys.executable),
         ]
+        self.assertEqual(
+            expected, list(FrozenRegistryEntries(Cls, frozen="windows_exe"))
+        )
 
-        with mock.patch.dict(comtypes.server.inprocserver._clsid_to_class):
-            comtypes.server.inprocserver._clsid_to_class.update({5678: Cls})
-            self.assertEqual(expected, list(RegistryEntries(Cls)))
-
-    @mock.patch.object(register, "_get_serverdll", lambda: r"my\target\server.dll")
-    @mock.patch.object(register, "sys")
-    def test_inproc_dll(self, _sys):
-        _sys.mock_add_spec(["frozen", "modules"])
-        _sys.frozen = "dll"
-        _sys.modules = sys.modules
+    @mock.patch.object(register, "_get_serverdll", return_value=SERVERDLL)
+    def test_inproc_dll(self, get_serverdll):
         reg_clsid = GUID.create_new()
         reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
 
@@ -499,21 +491,17 @@ class Test_Frozen_RegistryEntries(ut.TestCase):
 
         clsid_sub = rf"CLSID\{reg_clsid}"
         inproc_srv_sub = rf"{clsid_sub}\InprocServer32"
-        full_classname = f"{__name__}.Cls"
         expected = [
             (HKCR, clsid_sub, "", ""),
-            (HKCR, inproc_srv_sub, "", r"my\target\server.dll"),
-            (HKCR, inproc_srv_sub, "PythonClass", full_classname),
-            (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
+            (HKCR, inproc_srv_sub, "", self.SERVERDLL),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
-
-    @mock.patch.object(register, "_get_serverdll", lambda: r"my\target\server.dll")
-    @mock.patch.object(register, "sys")
-    def test_inproc_dll_reg_threading(self, _sys):
-        _sys.mock_add_spec(["frozen", "modules"])
-        _sys.frozen = "dll"
-        _sys.modules = sys.modules
+
+        entries = FrozenRegistryEntries(Cls, frozen="dll", frozendllhandle=1234)
+        self.assertEqual(expected, list(entries))
+        get_serverdll.assert_called_once_with(1234)
+
+    @mock.patch.object(register, "_get_serverdll", return_value=SERVERDLL)
+    def test_inproc_reg_threading(self, get_serverdll):
         reg_clsid = GUID.create_new()
         reg_threading = "Both"
         reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
@@ -525,12 +513,13 @@ class Test_Frozen_RegistryEntries(ut.TestCase):
 
         clsid_sub = rf"CLSID\{reg_clsid}"
         inproc_srv_sub = rf"{clsid_sub}\InprocServer32"
-        full_classname = f"{__name__}.Cls"
         expected = [
             (HKCR, clsid_sub, "", ""),
-            (HKCR, inproc_srv_sub, "", r"my\target\server.dll"),
-            (HKCR, inproc_srv_sub, "PythonClass", full_classname),
-            (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
+            (HKCR, inproc_srv_sub, "", self.SERVERDLL),
             (HKCR, inproc_srv_sub, "ThreadingModel", reg_threading),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(
+            expected,
+            list(FrozenRegistryEntries(Cls, frozen="dll", frozendllhandle=1234)),
+        )
+        get_serverdll.assert_called_once_with(1234)

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

@@ -1,12 +1,11 @@
-from pathlib import Path
 import tempfile
 import unittest as ut
+from pathlib import Path
 
-from comtypes import CoCreateInstance, GUID, shelllink
 import comtypes.hresult
+from comtypes import GUID, CoCreateInstance, shelllink
 from comtypes.persist import IPersistFile
 
-
 CLSID_ShellLink = GUID("{00021401-0000-0000-C000-000000000046}")
 
 

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

@@ -1,19 +1,18 @@
-from _ctypes import COMError
-from ctypes import byref, c_ubyte, POINTER
 import contextlib
-from pathlib import Path
 import unittest
+from _ctypes import COMError
+from ctypes import HRESULT, POINTER, OleDLL, byref, c_ubyte
+from ctypes.wintypes import DWORD, PWCHAR
+from pathlib import Path
 
 import comtypes
 import comtypes.client
 
-
 with contextlib.redirect_stdout(None):  # supress warnings
     mod = comtypes.client.GetModule("msvidctl.dll")
 
 from comtypes.gen.MSVidCtlLib import IStorage
 
-
 STATFLAG_DEFAULT = 0
 STGC_DEFAULT = 0
 STGM_CREATE = 0x00001000
@@ -29,6 +28,13 @@ STREAM_SEEK_SET = 0
 STG_E_PATHNOTFOUND = -2147287038
 
 
+_ole32 = OleDLL("ole32")
+
+_StgCreateDocfile = _ole32.StgCreateDocfile
+_StgCreateDocfile.argtypes = [PWCHAR, DWORD, DWORD, POINTER(POINTER(IStorage))]
+_StgCreateDocfile.restype = HRESULT
+
+
 class Test_IStorage(unittest.TestCase):
     CREATE_DOC_FLAG = (
         STGM_DIRECT
@@ -44,7 +50,7 @@ class Test_IStorage(unittest.TestCase):
 
     def _create_docfile(self) -> IStorage:
         stg = POINTER(IStorage)()
-        comtypes._ole32.StgCreateDocfile(None, self.CREATE_DOC_FLAG, 0, byref(stg))
+        _StgCreateDocfile(None, self.CREATE_DOC_FLAG, 0, byref(stg))
         return stg  # type: ignore
 
     def test_CreateStream(self):

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

@@ -1,23 +1,34 @@
 import unittest as ut
+from ctypes import HRESULT, POINTER, OleDLL, byref, c_ubyte, c_ulonglong, pointer
+from ctypes.wintypes import BOOL, HGLOBAL, ULARGE_INTEGER
 
-from ctypes import POINTER, byref, c_bool, c_ubyte, c_ulonglong, oledll, pointer
-import comtypes
 import comtypes.client
 
 comtypes.client.GetModule("portabledeviceapi.dll")
 from comtypes.gen.PortableDeviceApiLib import IStream
 
-
 STGC_DEFAULT = 0
 STREAM_SEEK_SET = 0
 STREAM_SEEK_CUR = 1
 STREAM_SEEK_END = 2
 
+_ole32 = OleDLL("ole32")
+
+_CreateStreamOnHGlobal = _ole32.CreateStreamOnHGlobal
+_CreateStreamOnHGlobal.argtypes = [HGLOBAL, BOOL, POINTER(POINTER(IStream))]
+_CreateStreamOnHGlobal.restype = HRESULT
+
+_shlwapi = OleDLL("shlwapi")
+
+_IStream_Size = _shlwapi.IStream_Size
+_IStream_Size.argtypes = [POINTER(IStream), POINTER(ULARGE_INTEGER)]
+_IStream_Size.restype = HRESULT
+
 
 def _create_stream() -> IStream:
     # Create an IStream
     stream = POINTER(IStream)()  # type: ignore
-    comtypes._ole32.CreateStreamOnHGlobal(None, c_bool(True), byref(stream))
+    _CreateStreamOnHGlobal(None, True, byref(stream))
     return stream  # type: ignore
 
 
@@ -92,7 +103,7 @@ class Test_SetSize(ut.TestCase):
         stream = _create_stream()
         stream.SetSize(42)
         pui = pointer(c_ulonglong())
-        oledll.shlwapi.IStream_Size(stream, pui)
+        _IStream_Size(stream, pui)
         self.assertEqual(pui.contents.value, 42)
 
 

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

@@ -1,7 +1,9 @@
-import unittest, sys
-from comtypes import IUnknown, GUID
+import sys
+import unittest
 from ctypes import *
 
+from comtypes import GUID, IUnknown
+
 
 def test_main():
     from test import test_support

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

@@ -5,12 +5,11 @@ from comtypes.tools.codegenerator import typeannotator
 from comtypes.tools.tlbparser import (
     BSTR_type,
     HRESULT_type,
-    VARIANT_type,
     VARIANT_BOOL_type,
+    VARIANT_type,
     void_type,
 )
 
-
 iunknown_type = typedesc.ComInterface(
     "IUnknown", None, "{00000000-0000-0000-C000-000000000046}", ["hidden"], None
 )

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

@@ -1,15 +1,16 @@
-import os
+import ctypes
+import sys
 import unittest
-from ctypes import POINTER, byref
+from ctypes.wintypes import MAX_PATH
+
 from comtypes import GUID, COMError
-from comtypes.automation import DISPATCH_METHOD
 from comtypes.typeinfo import (
-    LoadTypeLibEx,
+    TKIND_DISPATCH,
+    TKIND_INTERFACE,
+    GetModuleFileName,
     LoadRegTypeLib,
+    LoadTypeLibEx,
     QueryPathOfRegTypeLib,
-    TKIND_INTERFACE,
-    TKIND_DISPATCH,
-    TKIND_ENUM,
 )
 
 
@@ -94,5 +95,33 @@ class Test(unittest.TestCase):
         self.assertEqual(guid, ti.GetTypeAttr().guid)
 
 
+class Test_GetModuleFileName(unittest.TestCase):
+    def test_null_handler(self):
+        self.assertEqual(GetModuleFileName(None, MAX_PATH), sys.executable)
+
+    def test_loaded_module_handle(self):
+        import _ctypes
+
+        dll_path = _ctypes.__file__
+        hmodule = ctypes.WinDLL(dll_path)._handle
+        self.assertEqual(GetModuleFileName(hmodule, MAX_PATH), dll_path)
+
+    def test_invalid_handle(self):
+        with self.assertRaises(OSError) as ce:
+            GetModuleFileName(1, MAX_PATH)
+        ERROR_MOD_NOT_FOUND = 126
+        self.assertEqual(ce.exception.winerror, ERROR_MOD_NOT_FOUND)
+
+    def test_invalid_nsize(self):
+        import _ctypes
+
+        dll_path = _ctypes.__file__
+        hmodule = ctypes.WinDLL(dll_path)._handle
+        with self.assertRaises(OSError) as ce:
+            GetModuleFileName(hmodule, 0)
+        ERROR_INSUFFICIENT_BUFFER = 122
+        self.assertEqual(ce.exception.winerror, ERROR_INSUFFICIENT_BUFFER)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,7 +1,10 @@
-import unittest, os
+import os
+import unittest
 from copy import copy
 from ctypes import *
-from comtypes.client import GetModule, CreateObject
+
+from comtypes.client import CreateObject, GetModule
+from comtypes.GUID import _CoTaskMemFree
 from comtypes.patcher import Patch
 
 # ./urlhist.tlb was downloaded somewhere from the internet (?)
@@ -23,8 +26,8 @@ class _(object):
         for n, _ in self._fields_:
             setattr(result, n, getattr(self, n))
         url, title = self.pwcsUrl, self.pwcsTitle
-        windll.ole32.CoTaskMemFree(cast_field(self, "pwcsUrl", c_void_p))
-        windll.ole32.CoTaskMemFree(cast_field(self, "pwcsTitle", c_void_p))
+        _CoTaskMemFree(cast_field(self, "pwcsUrl", c_void_p))
+        _CoTaskMemFree(cast_field(self, "pwcsTitle", c_void_p))
         return result
 
 

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

@@ -66,7 +66,8 @@ class VariantTestCase(unittest.TestCase):
 
         missing = VARIANT.missing
         self.assertEqual(missing.vt, VT_ERROR)
-        self.assertRaises(NotImplementedError, lambda: missing.value)
+        with self.assertRaises(NotImplementedError):
+            missing.value
 
     def test_com_refcounts(self):
         # typelib for oleaut32
@@ -293,9 +294,10 @@ def run_test(rep, msg, func=None, previous={}, results={}):
 
 
 def check_perf(rep=20000):
-    from ctypes import c_int, byref
-    from comtypes.automation import VARIANT
+    from ctypes import byref, c_int
+
     import comtypes.automation
+    from comtypes.automation import VARIANT
 
     print(comtypes.automation)
     variable = c_int()