comtypes 1.4.10__zip → 1.4.12__zip

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

@@ -1,9 +1,13 @@
+import contextlib
 import time
 import unittest
 
 import comtypes
 import comtypes.client
-import comtypes.test
+
+with contextlib.redirect_stdout(None):  # supress warnings
+    comtypes.client.GetModule("msvidctl.dll")
+from comtypes.gen import MSVidCtlLib as msvidctl
 
 try:
     # pass Word libUUID
@@ -29,7 +33,7 @@ class Test_Word(unittest.TestCase):
     def setUp(self):
         try:
             comtypes.client.GetActiveObject("Word.Application")
-        except WindowsError:
+        except OSError:
             pass
         else:
             # seems word is running, we cannot test this.
@@ -67,5 +71,18 @@ class Test_Word(unittest.TestCase):
             comtypes.client.GetActiveObject("Word.Application")
 
 
+class Test_MSVidCtlLib(unittest.TestCase):
+    def test_register_and_revoke(self):
+        vidctl = comtypes.client.CreateObject(msvidctl.MSVidCtl)
+        with self.assertRaises(WindowsError):
+            comtypes.client.GetActiveObject(msvidctl.MSVidCtl)
+        handle = comtypes.client.RegisterActiveObject(vidctl, msvidctl.MSVidCtl)
+        activeobj = comtypes.client.GetActiveObject(msvidctl.MSVidCtl)
+        self.assertEqual(vidctl, activeobj)
+        comtypes.client.RevokeActiveObject(handle)
+        with self.assertRaises(WindowsError):
+            comtypes.client.GetActiveObject(msvidctl.MSVidCtl)
+
+
 if __name__ == "__main__":
     unittest.main()

comtypes-1.4.12/comtypes/test/test_hresult.py

@@ -0,0 +1,87 @@
+import doctest
+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)
+
+
+class Test_signed32bithex_to_int(ut.TestCase):
+    def test(self):
+        for val, expected in [
+            ("0x00000000", comtypes.hresult.S_OK),
+            ("0x00000001", comtypes.hresult.S_FALSE),
+            ("0x8000FFFF", comtypes.hresult.E_UNEXPECTED),
+            ("0x80004002", comtypes.hresult.E_NOINTERFACE),
+            # boundary values
+            ("0x7FFFFFFF", 2147483647),
+            ("0x80000000", -2147483648),
+            ("0xFFFFFFFF", -1),
+        ]:
+            with self.subTest(val=val, expected=expected):
+                self.assertEqual(comtypes.hresult.signed32bithex_to_int(val), expected)
+
+
+class Test_int_to_signed32bithex(ut.TestCase):
+    def test(self):
+        for val, expected in [
+            (comtypes.hresult.S_OK, "0x00000000"),
+            (comtypes.hresult.S_FALSE, "0x00000001"),
+            (comtypes.hresult.E_UNEXPECTED, "0x8000FFFF"),
+            (comtypes.hresult.E_NOINTERFACE, "0x80004002"),
+        ]:
+            with self.subTest(val=val, expected=expected):
+                self.assertEqual(comtypes.hresult.int_to_signed32bithex(val), expected)
+
+
+class DocTest(ut.TestCase):
+    def test(self):
+        doctest.testmod(
+            comtypes.hresult,
+            verbose=False,
+            optionflags=doctest.ELLIPSIS,
+            raise_on_error=True,
+        )

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

@@ -8,7 +8,14 @@ from comtypes import IUnknown
 from comtypes._memberspec import _fix_inout_args
 
 if TYPE_CHECKING:
-    from comtypes._memberspec import _ArgSpecElmType
+    from comtypes import hints  # type: ignore
+
+    _ArgSpecType = Tuple[
+        hints.ArgSpecElmType,
+        hints.ArgSpecElmType,
+        hints.ArgSpecElmType,
+        hints.ArgSpecElmType,
+    ]
 
 WSTRING = c_wchar_p
 
@@ -259,7 +266,7 @@ class Test_ArgsKwargsCombinations(ut.TestCase):
 
 
 class PermutedArgspecTestingParams(NamedTuple):
-    argspec: "Tuple[_ArgSpecElmType, _ArgSpecElmType, _ArgSpecElmType, _ArgSpecElmType]"
+    argspec: "_ArgSpecType"
     args: Tuple[Any, Any, Any]
     orig_ret_val: Tuple[Any, Any, Any]
     fixed_ret_val: List[Any]

comtypes-1.4.12/comtypes/test/test_messageloop.py

@@ -0,0 +1,117 @@
+import threading
+import time
+import unittest
+from ctypes import WinDLL
+from typing import Tuple
+from unittest.mock import Mock, patch
+
+import comtypes.messageloop
+from comtypes.messageloop import _MessageLoop
+
+_user32 = WinDLL("user32")
+_kernel32 = WinDLL("kernel32")
+
+PostThreadMessageW = _user32.PostThreadMessageW
+PostQuitMessage = _user32.PostQuitMessage
+GetCurrentThreadId = _kernel32.GetCurrentThreadId
+
+WM_QUIT = 0x0012
+WM_USER = 0x0400
+
+
+class InsertAndRemoveFilterTest(unittest.TestCase):
+    def test_insert_and_remove_filter(self):
+        msgloop = _MessageLoop()
+        flt = Mock(return_value=[False])
+        msgloop.insert_filter(flt)
+        msgloop.remove_filter(flt)
+
+
+class RunInThreadTest(unittest.TestCase):
+    def setUp(self):
+        self.msgloop = _MessageLoop()
+
+    def run_msgloop_in_thread(self) -> Tuple[threading.Thread, int]:
+        """Helper method to run message loop in a separate thread."""
+        thread_ids = []
+
+        def thread_target():
+            with threading.Lock():
+                thread_ids.append(GetCurrentThreadId())
+            self.msgloop.run()
+
+        th = threading.Thread(target=thread_target, daemon=True)
+        th.start()
+        time.sleep(0.1)  # Give thread time to start
+        assert len(thread_ids) == 1, "Thread ID was not captured"
+        return th, thread_ids[0]
+
+    def test_quit_message(self):
+        th, thread_id = self.run_msgloop_in_thread()
+        # Post WM_QUIT to terminate the message loop
+        PostThreadMessageW(thread_id, WM_QUIT, 0, 0)
+        th.join(timeout=1.0)  # Ensure the thread completes
+        self.assertFalse(th.is_alive())
+
+    def test_blocking_filter(self):
+        blocking_filter = Mock(return_value=[True])  # Blocking
+        self.msgloop.insert_filter(blocking_filter)
+        th, thread_id = self.run_msgloop_in_thread()
+        # Post a regular message first (should be filtered)
+        PostThreadMessageW(thread_id, WM_USER, 0, 0)
+        time.sleep(0.1)  # Give time for message processing
+        # Post WM_QUIT to terminate the message loop
+        PostThreadMessageW(thread_id, WM_QUIT, 0, 0)
+        th.join(timeout=2.0)  # Wait for completion
+        self.assertFalse(th.is_alive())
+        blocking_filter.assert_called()
+
+    def test_nonblocking_filter(self):
+        message_filter = Mock(return_value=[])  # Non-blocking
+        self.msgloop.insert_filter(message_filter)
+        th, thread_id = self.run_msgloop_in_thread()
+        # Post some test messages
+        PostThreadMessageW(thread_id, WM_USER, 123, 456)
+        PostThreadMessageW(thread_id, WM_USER, 789, 101112)
+        time.sleep(0.3)  # Give time for message processing
+        # Post WM_QUIT to terminate the message loop
+        PostThreadMessageW(thread_id, WM_QUIT, 0, 0)
+        th.join(timeout=2.0)  # Wait for completion
+        self.assertFalse(th.is_alive())
+        message_filter.assert_called()
+
+    def test_multiple_filters(self):
+        filter1 = Mock(return_value=[])  # Non-blocking
+        filter2 = Mock(return_value=[True])  # Blocking
+        filter3 = Mock(return_value=[])  # should not be called
+        self.msgloop.insert_filter(filter1, index=0)
+        self.msgloop.insert_filter(filter2, index=1)
+        self.msgloop.insert_filter(filter3, index=2)
+        th, thread_id = self.run_msgloop_in_thread()
+        PostThreadMessageW(thread_id, WM_USER, 123, 456)
+        time.sleep(1.0)  # Give time for message processing
+        # Post WM_QUIT to terminate the message loop
+        PostThreadMessageW(thread_id, WM_QUIT, 0, 0)
+        th.join(timeout=2.0)  # Wait for completion
+        self.assertFalse(th.is_alive())
+        # any() evaluates filters in order: filter1 (falsy) then filter2 (truthy)
+        # any() stops at filter2 because it returns a truthy value.
+        filter1.assert_called()
+        filter2.assert_called()
+        filter3.assert_not_called()
+
+    def test_raises_error_on_getmsg(self):
+        # Mock GetMessage to return -1 (error condition)
+        with patch.object(comtypes.messageloop, "GetMessage", return_value=-1):
+            with self.assertRaises(OSError):
+                self.msgloop.run()
+
+    def test_exit_normally_without_error(self):
+        def run_and_exit_quickly():
+            PostQuitMessage(0)  # Exit immediately
+            self.msgloop.run()
+
+        th = threading.Thread(target=run_and_exit_quickly, daemon=True)
+        th.start()
+        th.join(timeout=1.0)
+        self.assertFalse(th.is_alive())

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

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import unittest
 from ctypes import HRESULT, POINTER, c_int, pointer
 

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

@@ -11,7 +11,7 @@ from comtypes.client import CreateObject
 try:
     GUID.from_progid("MSScriptControl.ScriptControl")
     CreateObject("MSScriptControl.ScriptControl")
-except WindowsError:
+except OSError:
     # doesn't exist on Windows CE or in 64-bit.
     pass
 else:

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

@@ -3,7 +3,7 @@ import functools
 import importlib
 import inspect
 import unittest
-from ctypes import POINTER, c_double, c_long, pointer
+from ctypes import POINTER, c_double, c_long, c_longlong, pointer
 from decimal import Decimal
 
 import comtypes._npsupport
@@ -16,6 +16,7 @@ from comtypes.automation import (
     VT_BSTR,
     VT_DATE,
     VT_I4,
+    VT_I8,
     VT_VARIANT,
     _midlSAFEARRAY,
 )
@@ -23,13 +24,15 @@ from comtypes.safearray import safearray_as_ndarray
 
 try:
     import numpy
+
+    IMPORT_NUMPY_FAILED = False
 except ImportError:
-    numpy = None
+    IMPORT_NUMPY_FAILED = True
 
 
 def setUpModule():
     """Only run the module if we can import numpy."""
-    if numpy is None:
+    if IMPORT_NUMPY_FAILED:
         raise unittest.SkipTest("Skipping test_npsupport as numpy not installed.")
 
 
@@ -70,9 +73,7 @@ def enabled_disabled(disabled_error):
             from comtypes import npsupport
 
             if npsupport.enabled:
-                raise EnvironmentError(
-                    "Expected numpy interop not to be enabled but it is."
-                )
+                raise OSError("Expected numpy interop not to be enabled but it is.")
             with self.assertRaises(disabled_error):
                 func(self)
 
@@ -112,10 +113,6 @@ class NumpySupportTestCase(unittest.TestCase):
         self.assertTrue(isinstance(fourth, numpy.ndarray))
         self.assertTrue(isinstance(fifth, tuple))
 
-    @unittest.skip(
-        "Skipping because numpy cannot currently create an array of variants "
-        "because it doesn't recognise the VARIANT_BOOL typecode 'v'."
-    )
     def test_datetime64_ndarray(self):
         comtypes.npsupport.enable()
         dates = numpy.array(
@@ -184,7 +181,7 @@ class NumpySupportTestCase(unittest.TestCase):
     def test_VT_I4_ndarray(self):
         t = _midlSAFEARRAY(c_long)
 
-        in_arr = numpy.array([11, 22, 33])
+        in_arr = numpy.array([11, 22, 33], dtype=numpy.int32)
         sa = t.from_param(in_arr)
 
         arr = get_ndarray(sa)
@@ -194,6 +191,20 @@ class NumpySupportTestCase(unittest.TestCase):
         self.assertTrue((arr == in_arr).all())
         self.assertEqual(SafeArrayGetVartype(sa), VT_I4)
 
+    @enabled_disabled(disabled_error=ValueError)
+    def test_VT_I8_ndarray(self):
+        t = _midlSAFEARRAY(c_longlong)
+
+        in_arr = numpy.array([11, 22, 33], dtype=numpy.int64)
+        sa = t.from_param(in_arr)
+
+        arr = get_ndarray(sa)
+
+        self.assertTrue(isinstance(arr, numpy.ndarray))
+        self.assertEqual(numpy.dtype(int), arr.dtype)
+        self.assertTrue((arr == in_arr).all())
+        self.assertEqual(SafeArrayGetVartype(sa), VT_I8)
+
     @enabled_disabled(disabled_error=ValueError)
     def test_array(self):
         t = _midlSAFEARRAY(c_double)

comtypes-1.4.12/comtypes/test/test_persist.py

@@ -0,0 +1,71 @@
+import tempfile
+import unittest as ut
+from _ctypes import COMError
+from pathlib import Path
+
+from comtypes import GUID, CoCreateInstance, IPersist, hresult, persist
+from comtypes.automation import VARIANT
+
+CLSID_ShellLink = GUID("{00021401-0000-0000-C000-000000000046}")
+
+
+class Test_IPersist(ut.TestCase):
+    def test_GetClassID(self):
+        p = CoCreateInstance(CLSID_ShellLink).QueryInterface(IPersist)
+        self.assertEqual(p.GetClassID(), CLSID_ShellLink)
+
+
+class Test_IPersistFile(ut.TestCase):
+    def setUp(self):
+        td = tempfile.TemporaryDirectory()
+        self.addCleanup(td.cleanup)
+        self.tmp_dir = Path(td.name)
+
+    def _create_pf(self) -> persist.IPersistFile:
+        return CoCreateInstance(CLSID_ShellLink).QueryInterface(persist.IPersistFile)
+
+    def test_load(self):
+        pf = self._create_pf()
+        tgt_file = (self.tmp_dir / "tgt.txt").resolve()
+        tgt_file.touch()
+        pf.Load(str(tgt_file), persist.STGM_DIRECT)
+        self.assertEqual(pf.GetCurFile(), str(tgt_file))
+
+    def test_save(self):
+        pf = self._create_pf()
+        tgt_file = self.tmp_dir / "tgt.txt"
+        self.assertFalse(tgt_file.exists())
+        pf.Save(str(tgt_file), True)
+        self.assertEqual(pf.GetCurFile(), str(tgt_file))
+        self.assertTrue(tgt_file.exists())
+
+
+class Test_DictPropertyBag(ut.TestCase):
+    def create_itf_ptr(self) -> persist.IPropertyBag:
+        # Create a DictPropertyBag instance with some initial values
+        impl = persist.DictPropertyBag(Key1="value1", Key2=123, Key3=True)
+        # Get the IPropertyBag interface pointer
+        itf = impl.QueryInterface(persist.IPropertyBag)
+        return itf
+
+    def test_read_existing_properties(self):
+        itf = self.create_itf_ptr()
+        self.assertEqual(itf.Read("Key1", VARIANT(), None), "value1")
+        self.assertEqual(itf.Read("Key2", VARIANT(), None), 123)
+        self.assertEqual(itf.Read("Key3", VARIANT(), None), True)
+
+    def test_write_new_property(self):
+        itf = self.create_itf_ptr()
+        itf.Write("Key4", "new_value")
+        self.assertEqual(itf.Read("Key4", VARIANT(), None), "new_value")
+
+    def test_update_existing_property(self):
+        itf = self.create_itf_ptr()
+        itf.Write("Key1", "updated_value")
+        self.assertEqual(itf.Read("Key1", VARIANT(), None), "updated_value")
+
+    def test_read_non_existent_property(self):
+        itf = self.create_itf_ptr()
+        with self.assertRaises(COMError) as cm:
+            itf.Read("NonExistentProp", VARIANT(), None)
+        self.assertEqual(cm.exception.hresult, hresult.E_INVALIDARG)

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

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import unittest
 from ctypes import byref, pointer, sizeof
 

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

@@ -129,7 +129,8 @@ class SafeArrayTestCase(unittest.TestCase):
         self.assertEqual(SafeArrayGetVartype(sa), VT_I4)
 
         # TypeError: len() of unsized object
-        self.assertRaises(TypeError, lambda: t.from_param(object()))
+        with self.assertRaises(TypeError):
+            t.from_param(object())
 
     def test_VT_VARIANT(self):
         t = _midlSAFEARRAY(VARIANT)

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

@@ -8,7 +8,7 @@ import comtypes.typeinfo
 raise unittest.SkipTest("This test module cannot run as-is.  Investigate why")
 
 
-class TypeLib(object):
+class TypeLib:
     """This class collects IDL code fragments and eventually writes
     them into a .IDL file.  The compile() method compiles the IDL file
     into a typelibrary and registers it.  A function is also
@@ -64,7 +64,7 @@ class TypeLib(object):
         return tlb_path
 
 
-class Interface(object):
+class Interface:
     def __init__(self, header):
         self.header = header
         self.code = ""
@@ -257,7 +257,7 @@ class MyServer(comtypes.CoClass, ConnectableObjectMixin):
     def test_events(self):
         p = wrap(self.create())
 
-        class Handler(object):
+        class Handler:
             called = 0
 
             def OnSomething(self, this):
@@ -269,7 +269,7 @@ class MyServer(comtypes.CoClass, ConnectableObjectMixin):
         p.DoSomething()
         self.assertEqual(handler.called, 1)
 
-        class Handler(object):
+        class Handler:
             called = 0
 
             def IMyEventInterface_OnSomething(self):
@@ -292,7 +292,7 @@ class MyServer(comtypes.CoClass, ConnectableObjectMixin):
     def test_DoSomethingElse(self):
         p = wrap(self.create())
 
-        class Handler(object):
+        class Handler:
             called = 0
 
             def OnSomethingElse(self):
@@ -305,7 +305,7 @@ class MyServer(comtypes.CoClass, ConnectableObjectMixin):
         p.DoSomethingElse()
         self.assertEqual(handler.called, 1)
 
-        class Handler(object):
+        class Handler:
             called = 0
 
             def OnSomethingElse(self, this, presult):

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

@@ -3,6 +3,7 @@ import os
 import sys
 import unittest as ut
 import winreg
+from ctypes.wintypes import MAX_PATH
 from unittest import mock
 
 import comtypes
@@ -236,7 +237,7 @@ class Test_get_serverdll(ut.TestCase):
         self.assertEqual(dll_path, _get_serverdll(handle))
         (((hmodule, maxsize), _),) = GetModuleFileName.call_args_list
         self.assertEqual(handle, hmodule)
-        self.assertEqual(260, maxsize)
+        self.assertEqual(MAX_PATH, maxsize)
 
 
 class Test_InterpRegistryEntries(ut.TestCase):

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

@@ -58,7 +58,7 @@ class Test_IStorage(unittest.TestCase):
         filepath = Path(storage.Stat(STATFLAG_DEFAULT).pwcsName)
         self.assertTrue(filepath.exists())
         stream = storage.CreateStream("example", self.CREATE_STM_FLAG, 0, 0)
-        test_data = "Some data".encode("utf-8")
+        test_data = b"Some data"
         pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
         stream.RemoteWrite(pv, len(test_data))
         stream.Commit(STGC_DEFAULT)

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

@@ -7,7 +7,9 @@ import comtypes.client
 comtypes.client.GetModule("portabledeviceapi.dll")
 from comtypes.gen.PortableDeviceApiLib import IStream
 
+STATFLAG_DEFAULT = 0
 STGC_DEFAULT = 0
+STGTY_STREAM = 2
 STREAM_SEEK_SET = 0
 STREAM_SEEK_CUR = 1
 STREAM_SEEK_END = 2
@@ -35,7 +37,7 @@ def _create_stream() -> IStream:
 class Test_RemoteWrite(ut.TestCase):
     def test_RemoteWrite(self):
         stream = _create_stream()
-        test_data = "Some data".encode("utf-8")
+        test_data = b"Some data"
         pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
 
         written = stream.RemoteWrite(pv, len(test_data))
@@ -47,7 +49,7 @@ class Test_RemoteWrite(ut.TestCase):
 class Test_RemoteRead(ut.TestCase):
     def test_RemoteRead(self):
         stream = _create_stream()
-        test_data = "Some data".encode("utf-8")
+        test_data = b"Some data"
         pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
         stream.RemoteWrite(pv, len(test_data))
 
@@ -125,6 +127,24 @@ class Test_RemoteCopyTo(ut.TestCase):
         self.assertEqual(bytearray(dst_buf)[0:dst_read], test_data)
 
 
+class Test_Stat(ut.TestCase):
+    # https://learn.microsoft.com/en-us/windows/win32/api/objidl/nf-objidl-istream-stat
+    # https://learn.microsoft.com/en-us/windows/win32/api/objidl/ns-objidl-statstg
+    def test_returns_statstg_from_no_modified_stream(self):
+        stream = _create_stream()
+        statstg = stream.Stat(STATFLAG_DEFAULT)
+        self.assertIsNone(statstg.pwcsName)
+        self.assertEqual(statstg.type, STGTY_STREAM)
+        self.assertEqual(statstg.cbSize, 0)
+        mt, ct, at = statstg.mtime, statstg.ctime, statstg.atime
+        self.assertTrue(mt.dwLowDateTime == ct.dwLowDateTime == at.dwLowDateTime)
+        self.assertTrue(mt.dwHighDateTime == ct.dwHighDateTime == at.dwHighDateTime)
+        self.assertEqual(statstg.grfMode, 0)
+        self.assertEqual(statstg.grfLocksSupported, 0)
+        self.assertEqual(statstg.clsid, comtypes.GUID())
+        self.assertEqual(statstg.grfStateBits, 0)
+
+
 class Test_Clone(ut.TestCase):
     def test_Clone(self):
         orig = _create_stream()

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

@@ -1,6 +1,7 @@
 import ctypes
 import sys
 import unittest
+from ctypes.wintypes import MAX_PATH
 
 from comtypes import GUID, COMError
 from comtypes.typeinfo import (
@@ -96,14 +97,30 @@ class Test(unittest.TestCase):
 
 class Test_GetModuleFileName(unittest.TestCase):
     def test_null_handler(self):
-        self.assertEqual(GetModuleFileName(None, 260), sys.executable)
+        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, 260), dll_path)
+        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__":

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

@@ -18,7 +18,7 @@ from comtypes.gen import urlhistLib
 # generated code directly is to monkey-patch the
 # _STATURL.__ctypes_from_outparam__ method like this.
 @Patch(urlhistLib._STATURL)
-class _(object):
+class _:
     def __ctypes_from_outparam__(self):
         from comtypes.util import cast_field