comtypes 1.4.8__zip → 1.4.10__zip

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/test/__init__.py

@@ -64,7 +64,7 @@ def requires(resource, msg=None):
         return
     if not is_resource_enabled(resource):
         if msg is None:
-            msg = "Use of the `%s' resource not enabled" % resource
+            msg = f"Use of the `{resource}` resource not enabled"
         raise ResourceDenied(msg)
 
 
@@ -94,12 +94,10 @@ def get_tests(package, mask, verbosity):
         except ResourceDenied as detail:
             skipped.append(modname)
             if verbosity > 1:
-                print("Skipped %s: %s" % (modname, detail), file=sys.stderr)
+                print(f"Skipped {modname}: {detail}", file=sys.stderr)
             continue
         except Exception as detail:
-            print(
-                "Warning: could not import %s: %s" % (modname, detail), file=sys.stderr
-            )
+            print(f"Warning: could not import {modname}: {detail}", file=sys.stderr)
             continue
         for name in dir(mod):
             if name.startswith("_"):
@@ -121,8 +119,8 @@ def usage():
 
 def test_with_refcounts(runner, verbosity, testcase):
     """Run testcase several times, tracking reference counts."""
-    import gc
     import ctypes
+    import gc
 
     ptc = ctypes._pointer_type_cache.copy()
     cfc = ctypes._c_functype_cache.copy()
@@ -149,9 +147,9 @@ def test_with_refcounts(runner, verbosity, testcase):
         cleanup()
         refcounts[i] = sys.gettotalrefcount() - rc
     if [_f for _f in refcounts if _f]:
-        print("%s leaks:\n\t" % testcase, refcounts)
+        print(f"{testcase} leaks:\n\t", refcounts)
     elif verbosity:
-        print("%s: ok." % testcase)
+        print(f"{testcase}: ok.")
 
 
 class TestRunner(unittest.TextTestRunner):
@@ -180,21 +178,21 @@ class TestRunner(unittest.TextTestRunner):
                     len(skipped) != 1 and "s" or "",
                 )
             )
-            self.stream.writeln("Unavailable resources: %s" % ", ".join(requested))
+            self.stream.writeln(f"Unavailable resources: {', '.join(requested)}")
         else:
             self.stream.writeln(
-                "Ran %d test%s in %.3fs" % (run, run != 1 and "s" or "", timeTaken)
+                f"Ran {run} test{'s' if run != 1 else ''} in {timeTaken:.3f}s"
             )
         self.stream.writeln()
         if not result.wasSuccessful():
             self.stream.write("FAILED (")
             failed, errored = list(map(len, (result.failures, result.errors)))
             if failed:
-                self.stream.write("failures=%d" % failed)
+                self.stream.write(f"failures={failed}")
             if errored:
                 if failed:
                     self.stream.write(", ")
-                self.stream.write("errors=%d" % errored)
+                self.stream.write(f"errors={errored}")
             self.stream.writeln(")")
         else:
             self.stream.writeln("OK")

comtypes-1.4.10/comtypes/test/find_memleak.py

@@ -0,0 +1,72 @@
+import gc
+from ctypes import POINTER, Structure, WinDLL, WinError, byref, c_size_t, sizeof
+from ctypes.wintypes import BOOL, DWORD, HANDLE
+
+################################################################
+
+
+class PROCESS_MEMORY_COUNTERS(Structure):
+    _fields_ = [
+        ("cb", DWORD),
+        ("PageFaultCount", DWORD),
+        ("PeakWorkingSetSize", c_size_t),
+        ("WorkingSetSize", c_size_t),
+        ("QuotaPeakPagedPoolUsage", c_size_t),
+        ("QuotaPagedPoolUsage", c_size_t),
+        ("QuotaPeakNonPagedPoolUsage", c_size_t),
+        ("QuotaNonPagedPoolUsage", c_size_t),
+        ("PagefileUsage", c_size_t),
+        ("PeakPagefileUsage", c_size_t),
+    ]
+
+    def __init__(self):
+        self.cb = sizeof(self)
+
+    def dump(self):
+        for n, _ in self._fields_[2:]:
+            print(n, getattr(self, n) / 1e6)
+
+
+_psapi = WinDLL("psapi")
+
+_GetProcessMemoryInfo = _psapi.GetProcessMemoryInfo
+_GetProcessMemoryInfo.argtypes = [HANDLE, POINTER(PROCESS_MEMORY_COUNTERS), DWORD]
+_GetProcessMemoryInfo.restype = BOOL
+
+
+def wss():
+    # Return the working set size (memory used by process)
+    pmi = PROCESS_MEMORY_COUNTERS()
+    if not _GetProcessMemoryInfo(-1, byref(pmi), sizeof(pmi)):
+        raise WinError()
+    return pmi.WorkingSetSize
+
+
+LOOPS = 10, 1000
+
+
+def find_memleak(func, loops=LOOPS):
+    # call 'func' several times, so that memory consumption
+    # stabilizes:
+    for j in range(loops[0]):
+        for k in range(loops[1]):
+            func()
+    gc.collect()
+    gc.collect()
+    gc.collect()
+    bytes = wss()
+    # call 'func' several times, recording the difference in
+    # memory consumption before and after the call.  Repeat this a
+    # few times, and return a list containing the memory
+    # consumption differences.
+    for j in range(loops[0]):
+        for k in range(loops[1]):
+            func()
+    gc.collect()
+    gc.collect()
+    gc.collect()
+    # return the increased in process size
+    result = wss() - bytes
+    # Sometimes the process size did decrease, we do not report leaks
+    # in this case:
+    return max(result, 0)

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/test/runtests.py

@@ -1,4 +1,5 @@
 import sys
+
 import comtypes.test
 
 

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/test/setup.py

@@ -1,6 +1,7 @@
 # all the unittests can be converted to exe-files.
-from distutils.core import setup
 import glob
+from distutils.core import setup
+
 import py2exe
 
 setup(name="test_*", console=glob.glob("test_*.py"))

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/test/test_BSTR.py

@@ -1,17 +1,15 @@
-import unittest, os
-from ctypes import *
-from comtypes import BSTR
-from comtypes.test import requires
-
-##requires("memleaks")
+import unittest
+from ctypes import WinDLL
+from ctypes.wintypes import UINT
 
+from comtypes import BSTR
 from comtypes.test.find_memleak import find_memleak
 
 
 class Test(unittest.TestCase):
     def check_leaks(self, func, limit=0):
         bytes = find_memleak(func)
-        self.assertFalse(bytes > limit, "Leaks %d bytes" % bytes)
+        self.assertFalse(bytes > limit, f"Leaks {bytes} bytes")
 
     def test_creation(self):
         def doit():
@@ -27,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.8 → comtypes-1.4.10}/comtypes/test/test_GUID.py

@@ -1,4 +1,5 @@
 import unittest
+
 from comtypes import GUID
 
 

{comtypes-1.4.8 → comtypes-1.4.10}/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.8 → comtypes-1.4.10}/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.8 → comtypes-1.4.10}/comtypes/test/test_avmc.py

@@ -37,7 +37,7 @@ class Test(unittest.TestCase):
 
     def check_leaks(self, func, limit=0):
         bytes = find_memleak(func)
-        self.assertFalse(bytes > limit, "Leaks %d bytes" % bytes)
+        self.assertFalse(bytes > limit, f"Leaks {bytes} bytes")
 
 
 if __name__ == "__main__":

{comtypes-1.4.8 → comtypes-1.4.10}/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)
 

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/test/test_casesensitivity.py

@@ -31,13 +31,11 @@ class TestCase(unittest.TestCase):
         # names in the base class __map_case__ must also appear in the
         # subclass.
         for name in iem.IWebBrowser.__map_case__:
-            self.assertTrue(
-                name in iem.IWebBrowserApp.__map_case__, "%s missing" % name
-            )
-            self.assertTrue(name in iem.IWebBrowser2.__map_case__, "%s missing" % name)
+            self.assertTrue(name in iem.IWebBrowserApp.__map_case__, f"{name} missing")
+            self.assertTrue(name in iem.IWebBrowser2.__map_case__, f"{name} missing")
 
         for name in iem.IWebBrowserApp.__map_case__:
-            self.assertTrue(name in iem.IWebBrowser2.__map_case__, "%s missing" % name)
+            self.assertTrue(name in iem.IWebBrowser2.__map_case__, f"{name} missing")
 
 
 if __name__ == "__main__":

{comtypes-1.4.8 → comtypes-1.4.10}/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.8 → comtypes-1.4.10}/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.8 → comtypes-1.4.10}/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.8 → comtypes-1.4.10}/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.8 → comtypes-1.4.10}/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
 
 
@@ -74,7 +74,7 @@ class Test(unittest.TestCase):
                 item.ProcessImageFileName
 
         bytes = find_memleak(doit, (20, 20))
-        self.assertFalse(bytes, "Leaks %d bytes" % bytes)
+        self.assertFalse(bytes, f"Leaks {bytes} bytes")
 
     @unittest.skip("This test takes a long time.  Do we need it? Can it be rewritten?")
     def test_leaks_2(self):
@@ -87,7 +87,7 @@ class Test(unittest.TestCase):
             iter(apps).Next(99)
 
         bytes = find_memleak(doit, (20, 20))
-        self.assertFalse(bytes, "Leaks %d bytes" % bytes)
+        self.assertFalse(bytes, f"Leaks {bytes} bytes")
 
     @unittest.skip("This test takes a long time.  Do we need it? Can it be rewritten?")
     def test_leaks_3(self):
@@ -102,7 +102,7 @@ class Test(unittest.TestCase):
                     pass
 
         bytes = find_memleak(doit, (20, 20))
-        self.assertFalse(bytes, "Leaks %d bytes" % bytes)
+        self.assertFalse(bytes, f"Leaks {bytes} bytes")
 
 
 class TestCollectionInterface(unittest.TestCase):

comtypes-1.4.10/comtypes/test/test_comobject.py

@@ -0,0 +1,146 @@
+import ctypes
+import unittest as ut
+from ctypes import POINTER, byref, pointer
+from unittest import mock
+
+import comtypes.client
+from comtypes import CLSCTX_SERVER, COMObject, IUnknown, hresult
+from comtypes._post_coinit.misc import _CoCreateInstance
+from comtypes.automation import IDispatch
+
+comtypes.client.GetModule("UIAutomationCore.dll")
+comtypes.client.GetModule("scrrun.dll")
+from comtypes.gen import Scripting as scrrun
+from comtypes.gen import UIAutomationClient as uiac
+from comtypes.gen import stdole
+
+
+class Test_QueryInterface(ut.TestCase):
+    def test_custom_interface(self):
+        iuia = uiac.CUIAutomation().QueryInterface(uiac.IUIAutomation)
+        self.assertTrue(bool(iuia))
+        self.assertEqual(iuia.AddRef(), 2)
+        punk = iuia.QueryInterface(IUnknown)
+        self.assertEqual(iuia.AddRef(), 4)
+        self.assertEqual(punk.AddRef(), 5)
+        self.assertEqual(iuia.Release(), 4)
+        del iuia
+        self.assertEqual(punk.Release(), 2)
+        self.assertEqual(punk.Release(), 1)
+
+    def test_dispatch_interface(self):
+        dic = scrrun.Dictionary().QueryInterface(scrrun.IDictionary)
+        self.assertTrue(bool(dic))
+        self.assertEqual(dic.GetTypeInfoCount(), 1)
+        self.assertEqual(
+            dic.GetTypeInfo(0).GetTypeAttr().guid,
+            scrrun.IDictionary._iid_,
+        )
+        self.assertEqual(dic.GetIDsOfNames("Add"), [1])
+
+
+class Test_IUnknown_QueryInterface(ut.TestCase):
+    def test_e_pointer(self):
+        hr = scrrun.Dictionary().IUnknown_QueryInterface(
+            None, pointer(scrrun.IDictionary._iid_), ctypes.c_void_p()
+        )
+        self.assertEqual(hr, hresult.E_POINTER)
+
+    def test_e_no_interface(self):
+        hr = scrrun.Dictionary().IUnknown_QueryInterface(
+            None, pointer(uiac.IUIAutomation._iid_), ctypes.c_void_p()
+        )
+        self.assertEqual(hr, hresult.E_NOINTERFACE)
+
+    def test_valid_pointer(self):
+        ptr = ctypes.c_void_p()
+        _CoCreateInstance(
+            byref(scrrun.Dictionary._reg_clsid_),
+            None,
+            CLSCTX_SERVER,
+            byref(scrrun.IDictionary._iid_),
+            byref(ptr),
+        )
+        before_val = ptr.value
+        hr = scrrun.Dictionary().IUnknown_QueryInterface(
+            None, pointer(scrrun.IDictionary._iid_), ptr
+        )
+        self.assertEqual(hr, hresult.S_OK)
+        self.assertEqual(ptr.value, before_val)
+
+    def test_valid_interface(self):
+        dic = POINTER(IDispatch)()
+        hr = scrrun.Dictionary().IUnknown_QueryInterface(
+            None, pointer(scrrun.IDictionary._iid_), byref(dic)
+        )
+        self.assertEqual(hr, hresult.S_OK)
+        self.assertEqual(dic.AddRef(), 2)  # type: ignore
+        self.assertEqual(dic.Release(), 1)  # type: ignore
+        self.assertEqual(dic.GetTypeInfoCount(), 1)  # type: ignore
+
+
+class Test_IUnknown_AddRef_IUnknown_Release(ut.TestCase):
+    def test(self):
+        cuia = uiac.CUIAutomation()
+        self.assertEqual(cuia.IUnknown_AddRef(None), 1)
+        self.assertEqual(cuia.IUnknown_AddRef(None), 2)
+        with mock.patch.object(COMObject, "_final_release_") as release:
+            self.assertEqual(cuia.IUnknown_Release(None), 1)
+            release.assert_not_called()
+            self.assertEqual(cuia.IUnknown_Release(None), 0)
+            release.assert_called_once_with()
+
+
+class Test_ISupportErrorInfo_InterfaceSupportsErrorInfo(ut.TestCase):
+    def test_s_ok(self):
+        cuia = uiac.CUIAutomation()
+        self.assertEqual(
+            cuia.ISupportErrorInfo_InterfaceSupportsErrorInfo(
+                None, pointer(IUnknown._iid_)
+            ),
+            hresult.S_OK,
+        )
+        self.assertEqual(
+            cuia.ISupportErrorInfo_InterfaceSupportsErrorInfo(
+                None, pointer(uiac.IUIAutomation._iid_)
+            ),
+            hresult.S_OK,
+        )
+
+    def test_s_false(self):
+        cuia = uiac.CUIAutomation()
+        self.assertEqual(
+            cuia.ISupportErrorInfo_InterfaceSupportsErrorInfo(
+                None, pointer(IDispatch._iid_)
+            ),
+            hresult.S_FALSE,
+        )
+        self.assertEqual(
+            cuia.ISupportErrorInfo_InterfaceSupportsErrorInfo(
+                None, pointer(scrrun.IDictionary._iid_)
+            ),
+            hresult.S_FALSE,
+        )
+
+
+class Test_IProvideClassInfo_GetClassInfo(ut.TestCase):
+    def test(self):
+        tinfo = uiac.CUIAutomation().IProvideClassInfo_GetClassInfo()
+        self.assertEqual(tinfo.GetTypeAttr().guid, uiac.CUIAutomation._reg_clsid_)
+
+
+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_,
+        )
+
+
+class Test_IPersist_GetClassID(ut.TestCase):
+    def test(self):
+        self.assertEqual(
+            uiac.CUIAutomation().IPersist_GetClassID(),
+            uiac.CUIAutomation._reg_clsid_,
+        )