comtypes 1.4.8__zip → 1.4.9__zip

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/server/register.py

@@ -36,17 +36,18 @@ Now, debug the object, and when done delete logging info:
   python mycomobj.py /nodebug
 """
 
-import sys
+import logging
 import os
+import sys
 import winreg
-import logging
+from ctypes import WinError, c_ulong, c_wchar_p, create_string_buffer, sizeof, windll
+from typing import Iterator, Tuple
 
 import comtypes
-from comtypes.typeinfo import LoadTypeLibEx, UnRegisterTypeLib, REGKIND_REGISTER
+import comtypes.server.inprocserver
 from comtypes.hresult import *
 from comtypes.server import w_getopt
-import comtypes.server.inprocserver
-from ctypes import windll, c_ulong, c_wchar_p, WinError, sizeof, create_string_buffer
+from comtypes.typeinfo import REGKIND_REGISTER, LoadTypeLibEx, UnRegisterTypeLib
 
 _debug = logging.getLogger(__name__).debug
 
@@ -100,7 +101,7 @@ class Registrar(object):
                 'DeleteKey( %s\\CLSID\\%s\\Logging"'
                 % (_explain(winreg.HKEY_CLASSES_ROOT), clsid)
             )
-            hkey = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"CLSID\%s" % clsid)
+            hkey = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}")
             winreg.DeleteKey(hkey, "Logging")
         except WindowsError as detail:
             if get_winerror(detail) != 2:
@@ -115,7 +116,7 @@ class Registrar(object):
             'CreateKey( %s\\CLSID\\%s\\Logging"'
             % (_explain(winreg.HKEY_CLASSES_ROOT), clsid)
         )
-        hkey = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\Logging" % clsid)
+        hkey = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\Logging")
         for item in levels:
             name, value = item.split("=")
             v = getattr(logging, value)
@@ -147,8 +148,7 @@ class Registrar(object):
             self._register(cls, executable)
 
     def _register(self, cls, executable=None):
-        table = self._registry_entries(cls)
-        table.sort()
+        table = sorted(RegistryEntries(cls))
         _debug("Registering %s", cls)
         for hkey, subkey, valuename, value in table:
             _debug("[%s\\%s]", _explain(hkey), subkey)
@@ -159,7 +159,7 @@ class Registrar(object):
         tlib = getattr(cls, "_reg_typelib_", None)
         if tlib is not None:
             if hasattr(sys, "frozendllhandle"):
-                dll = self._get_serverdll()
+                dll = _get_serverdll()
                 _debug("LoadTypeLibEx(%s, REGKIND_REGISTER)", dll)
                 LoadTypeLibEx(dll, REGKIND_REGISTER)
             else:
@@ -184,7 +184,7 @@ class Registrar(object):
     def _unregister(self, cls, force=False):
         # If force==False, we only remove those entries that we
         # actually would have written.  It seems ATL does the same.
-        table = [t[:2] for t in self._registry_entries(cls)]
+        table = [t[:2] for t in RegistryEntries(cls)]
         # only unique entries
         table = list(set(table))
         table.sort()
@@ -214,23 +214,29 @@ class Registrar(object):
                     raise
         _debug("Done")
 
-    def _get_serverdll(self):
-        """Return the pathname of the dll hosting the COM object."""
-        handle = getattr(sys, "frozendllhandle", None)
-        if handle is not None:
-            buf = create_string_buffer(260)
-            windll.kernel32.GetModuleFileNameA(handle, buf, sizeof(buf))
-            return buf[:]
-        import _ctypes
 
-        return _ctypes.__file__
+def _get_serverdll():
+    """Return the pathname of the dll hosting the COM object."""
+    handle = getattr(sys, "frozendllhandle", None)
+    if handle is not None:
+        buf = create_string_buffer(260)
+        windll.kernel32.GetModuleFileNameA(handle, buf, sizeof(buf))
+        return buf[:]
+    import _ctypes
+
+    return _ctypes.__file__
+
+
+class RegistryEntries(object):
+    def __init__(self, cls):
+        self._cls = cls
 
     def _get_full_classname(self, cls):
         """Return <modulename>.<classname> for 'cls'."""
         modname = cls.__module__
         if modname == "__main__":
             modname = os.path.splitext(os.path.basename(sys.argv[0]))[0]
-        return "%s.%s" % (modname, cls.__name__)
+        return f"{modname}.{cls.__name__}"
 
     def _get_pythonpath(self, cls):
         """Return the filesystem path of the module containing 'cls'."""
@@ -238,8 +244,8 @@ class Registrar(object):
         dirname = os.path.dirname(sys.modules[modname].__file__)
         return os.path.abspath(dirname)
 
-    def _registry_entries(self, cls):
-        """Return a sequence of tuples containing registry entries.
+    def __iter__(self) -> Iterator[Tuple[int, str, str, str]]:
+        """Return a iterator of tuples containing registry entries.
 
         The tuples must be (key, subkey, name, value).
 
@@ -259,16 +265,13 @@ class Registrar(object):
         Note that the first part of the progid string is typically the
         IDL library name of the type library containing the coclass.
         """
+        cls = self._cls
         HKCR = winreg.HKEY_CLASSES_ROOT
 
-        # table format: rootkey, subkey, valuename, value
-        table = []
-        append = lambda *args: table.append(args)
-
         # basic entry - names the comobject
-        reg_clsid = str(
-            cls._reg_clsid_
-        )  # that's the only required attribute for registration
+
+        # that's the only required attribute for registration
+        reg_clsid = str(cls._reg_clsid_)
         reg_desc = getattr(cls, "_reg_desc_", "")
         if not reg_desc:
             # Simple minded algorithm to construct a description from
@@ -278,95 +281,83 @@ class Registrar(object):
             )
             if reg_desc:
                 reg_desc = reg_desc.replace(".", " ")
-        append(HKCR, "CLSID\\%s" % reg_clsid, "", reg_desc)
+        yield (HKCR, f"CLSID\\{reg_clsid}", "", reg_desc)
 
         reg_progid = getattr(cls, "_reg_progid_", None)
         if reg_progid:
             # for ProgIDFromCLSID:
-            append(HKCR, "CLSID\\%s\\ProgID" % reg_clsid, "", reg_progid)  # 1
+            yield (HKCR, f"CLSID\\{reg_clsid}\\ProgID", "", reg_progid)  # 1
 
             # for CLSIDFromProgID
             if reg_desc:
-                append(HKCR, reg_progid, "", reg_desc)  # 2
-            append(HKCR, "%s\\CLSID" % reg_progid, "", reg_clsid)  # 3
+                yield (HKCR, reg_progid, "", reg_desc)  # 2
+            yield (HKCR, f"{reg_progid}\\CLSID", "", reg_clsid)  # 3
 
             reg_novers_progid = getattr(cls, "_reg_novers_progid_", None)
             if reg_novers_progid:
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\VersionIndependentProgID" % reg_clsid,  # 1a
+                    f"CLSID\\{reg_clsid}\\VersionIndependentProgID",  # 1a
                     "",
                     reg_novers_progid,
                 )
                 if reg_desc:
-                    append(HKCR, reg_novers_progid, "", reg_desc)  # 2a
-                append(HKCR, "%s\\CurVer" % reg_novers_progid, "", reg_progid)  #
-                append(HKCR, "%s\\CLSID" % reg_novers_progid, "", reg_clsid)  # 3a
+                    yield (HKCR, reg_novers_progid, "", reg_desc)  # 2a
+                yield (HKCR, f"{reg_novers_progid}\\CurVer", "", reg_progid)  #
+                yield (HKCR, f"{reg_novers_progid}\\CLSID", "", reg_clsid)  # 3a
 
-        clsctx = getattr(cls, "_reg_clsctx_", 0)
+        clsctx: int = getattr(cls, "_reg_clsctx_", 0)
+        localsvr_ctx = bool(clsctx & comtypes.CLSCTX_LOCAL_SERVER)
+        inprocsvr_ctx = bool(clsctx & comtypes.CLSCTX_INPROC_SERVER)
 
-        if clsctx & comtypes.CLSCTX_LOCAL_SERVER and not hasattr(
-            sys, "frozendllhandle"
-        ):
+        if localsvr_ctx and not hasattr(sys, "frozendllhandle"):
             exe = sys.executable
             if " " in exe:
-                exe = '"%s"' % exe
+                exe = f'"{exe}"'
             if not hasattr(sys, "frozen"):
                 if not __debug__:
-                    exe = "%s -O" % exe
+                    exe = f"{exe} -O"
                 script = os.path.abspath(sys.modules[cls.__module__].__file__)
                 if " " in script:
-                    script = '"%s"' % script
-                append(
-                    HKCR,
-                    "CLSID\\%s\\LocalServer32" % reg_clsid,
-                    "",
-                    "%s %s" % (exe, script),
-                )
+                    script = f'"{script}"'
+                yield (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", f"{exe} {script}")
             else:
-                append(HKCR, "CLSID\\%s\\LocalServer32" % reg_clsid, "", "%s" % exe)
+                yield (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", f"{exe}")
 
         # Register InprocServer32 only when run from script or from
         # py2exe dll server, not from py2exe exe server.
-        if clsctx & comtypes.CLSCTX_INPROC_SERVER and getattr(sys, "frozen", None) in (
-            None,
-            "dll",
-        ):
-            append(
-                HKCR, "CLSID\\%s\\InprocServer32" % reg_clsid, "", self._get_serverdll()
-            )
+        if inprocsvr_ctx and getattr(sys, "frozen", None) in (None, "dll"):
+            yield (HKCR, rf"CLSID\{reg_clsid}\InprocServer32", "", _get_serverdll())
             # only for non-frozen inproc servers the PythonPath/PythonClass is needed.
             if (
                 not hasattr(sys, "frozendllhandle")
                 or not comtypes.server.inprocserver._clsid_to_class
             ):
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\InprocServer32" % reg_clsid,
+                    rf"CLSID\{reg_clsid}\InprocServer32",
                     "PythonClass",
                     self._get_full_classname(cls),
                 )
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\InprocServer32" % reg_clsid,
+                    rf"CLSID\{reg_clsid}\InprocServer32",
                     "PythonPath",
                     self._get_pythonpath(cls),
                 )
 
             reg_threading = getattr(cls, "_reg_threading_", None)
             if reg_threading is not None:
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\InprocServer32" % reg_clsid,
+                    rf"CLSID\{reg_clsid}\InprocServer32",
                     "ThreadingModel",
                     reg_threading,
                 )
 
         reg_tlib = getattr(cls, "_reg_typelib_", None)
         if reg_tlib is not None:
-            append(HKCR, "CLSID\\%s\\Typelib" % reg_clsid, "", reg_tlib[0])
-
-        return table
+            yield (HKCR, rf"CLSID\{reg_clsid}\Typelib", "", reg_tlib[0])
 
 
 ################################################################
@@ -381,10 +372,7 @@ def unregister(cls):
 
 
 def UseCommandLine(*classes):
-    usage = (
-        """Usage: %s [-regserver] [-unregserver] [-nodebug] [-f logformat] [-l loggername=level]"""
-        % sys.argv[0]
-    )
+    usage = f"""Usage: {sys.argv[0]} [-regserver] [-unregserver] [-nodebug] [-f logformat] [-l loggername=level]"""
     opts, args = w_getopt.w_getopt(
         sys.argv[1:], "regserver unregserver embedding l: f: nodebug"
     )

comtypes-1.4.9/comtypes/server/w_getopt.py

@@ -0,0 +1,48 @@
+from typing import Sequence, Tuple
+
+
+class GetoptError(Exception):
+    pass
+
+
+def w_getopt(
+    args: Sequence[str], options: str
+) -> Tuple[Sequence[Tuple[str, str]], Sequence[str]]:
+    """A getopt for Windows.
+
+    Options may start with either '-' or '/', the option names may
+    have more than one letter (/tlb or -RegServer), and option names
+    are case insensitive.
+
+    Returns two elements, just as getopt.getopt.  The first is a list
+    of (option, value) pairs in the same way getopt.getopt does, but
+    there is no '-' or '/' prefix to the option name, and the option
+    name is always lower case.  The second is the list of arguments
+    which do not belong to an option.
+
+    Different from getopt.getopt, a single argument not belonging to an option
+    does not terminate parsing.
+    """
+    opts = []
+    arguments = []
+    while args:
+        if args[0][:1] in "/-":
+            arg = args[0][1:]  # strip the '-' or '/'
+            arg = arg.lower()
+
+            if arg + ":" in options:
+                try:
+                    opts.append((arg, args[1]))
+                except IndexError:
+                    raise GetoptError(f"option '{args[0]}' requires an argument")
+                args = args[1:]
+            elif arg in options:
+                opts.append((arg, ""))
+            else:
+                raise GetoptError(f"invalid option '{args[0]}'")
+            args = args[1:]
+        else:
+            arguments.append(args[0])
+            args = args[1:]
+
+    return opts, arguments

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/shelllink.py

@@ -2,7 +2,7 @@ from ctypes import c_char_p, c_int, c_short, c_wchar_p
 from ctypes import POINTER
 from ctypes import byref, create_string_buffer, create_unicode_buffer
 from ctypes.wintypes import DWORD, WIN32_FIND_DATAA, WIN32_FIND_DATAW, MAX_PATH
-from typing import Tuple, TYPE_CHECKING
+from typing import Tuple, TYPE_CHECKING, Literal
 
 from comtypes import IUnknown, GUID, COMMETHOD, HRESULT, CoClass
 
@@ -143,7 +143,7 @@ class IShellLinkA(IUnknown):
         def ShowCmd(self, piShowCmd: int) -> None: ...
         def SetIconLocation(self, pszIconPath: bytes, iIcon: int) -> hints.Hresult: ...
         def SetRelativePath(
-            self, pszPathRel: bytes, dwReserved: hints.Literal[0]
+            self, pszPathRel: bytes, dwReserved: Literal[0]
         ) -> hints.Hresult: ...
         def Resolve(self, hwnd: int, fFlags: int) -> hints.Hresult: ...
         def SetPath(self, pszFile: bytes) -> hints.Hresult: ...
@@ -278,7 +278,7 @@ class IShellLinkW(IUnknown):
         def ShowCmd(self, piShowCmd: int) -> None: ...
         def SetIconLocation(self, pszIconPath: str, iIcon: int) -> hints.Hresult: ...
         def SetRelativePath(
-            self, pszPathRel: str, dwReserved: hints.Literal[0]
+            self, pszPathRel: str, dwReserved: Literal[0]
         ) -> hints.Hresult: ...
         def Resolve(self, hwnd: int, fFlags: int) -> hints.Hresult: ...
         def SetPath(self, pszFile: str) -> hints.Hresult: ...
@@ -317,26 +317,3 @@ class ShellLink(CoClass):
     _reg_clsid_ = GUID("{00021401-0000-0000-C000-000000000046}")
     _idlflags_ = []
     _com_interfaces_ = [IShellLinkW, IShellLinkA]
-
-
-if __name__ == "__main__":
-    import sys
-    import comtypes
-    from comtypes.client import CreateObject
-    from comtypes.persist import IPersistFile
-
-    shortcut = CreateObject(ShellLink)
-    print(shortcut)
-    ##help(shortcut)
-
-    shortcut.SetPath(sys.executable)
-
-    shortcut.SetDescription("Python %s" % sys.version)
-    shortcut.SetIconLocation(sys.executable, 1)
-
-    print(shortcut.GetPath(2))
-    print(shortcut.GetIconLocation())
-
-    pf = shortcut.QueryInterface(IPersistFile)
-    pf.Save("foo.lnk", True)
-    print(pf.GetCurFile())

{comtypes-1.4.8 → comtypes-1.4.9}/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("_"):
@@ -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.8 → comtypes-1.4.9}/comtypes/test/test_BSTR.py

@@ -1,17 +1,14 @@
-import unittest, os
-from ctypes import *
-from comtypes import BSTR
-from comtypes.test import requires
-
-##requires("memleaks")
+import unittest
+from ctypes import WINFUNCTYPE, c_uint, c_void_p, oledll, windll
 
+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():

{comtypes-1.4.8 → comtypes-1.4.9}/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.9}/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.9}/comtypes/test/test_collections.py

@@ -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.9/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
+import comtypes.client
+from comtypes import COMObject, IUnknown, hresult
+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()
+        ctypes.oledll.ole32.CoCreateInstance(
+            byref(scrrun.Dictionary._reg_clsid_),
+            None,
+            comtypes.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_,
+        )