comtypes 1.4.8__zip → 1.4.10__zip

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

@@ -1,15 +1,15 @@
-import os
+import ctypes
+import sys
 import unittest
-from ctypes import POINTER, byref
+
 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 +94,17 @@ class Test(unittest.TestCase):
         self.assertEqual(guid, ti.GetTypeAttr().guid)
 
 
+class Test_GetModuleFileName(unittest.TestCase):
+    def test_null_handler(self):
+        self.assertEqual(GetModuleFileName(None, 260), 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)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -194,23 +194,6 @@ class VariantTestCase(unittest.TestCase):
         v.value = ""
         self.assertEqual(v.vt, VT_BSTR)
 
-    @unittest.skip(
-        "Fails on creating `TestComServerLib.TestComServer`.  Library not registered."
-    )
-    def test_UDT(self):
-        from comtypes.gen.TestComServerLib import MYCOLOR
-
-        v = VARIANT(MYCOLOR(red=1.0, green=2.0, blue=3.0))
-        value = v.value
-        self.assertEqual((1.0, 2.0, 3.0), (value.red, value.green, value.blue))
-
-        def func():
-            v = VARIANT(MYCOLOR(red=1.0, green=2.0, blue=3.0))
-            return v.value
-
-        bytes = find_memleak(func)
-        self.assertFalse(bytes, "Leaks %d bytes" % bytes)
-
     def test_ctypes_in_variant(self):
         v = VARIANT()
         objs = [
@@ -310,9 +293,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()

comtypes-1.4.10/comtypes/test/test_w_getopt.py

@@ -0,0 +1,29 @@
+import unittest
+
+from comtypes.server.w_getopt import GetoptError, w_getopt
+
+
+class TestCase(unittest.TestCase):
+    def test_1(self):
+        args = "-embedding spam /RegServer foo /UnregSERVER blabla".split()
+        opts, args = w_getopt(args, "regserver unregserver embedding".split())
+        self.assertEqual(
+            opts, [("embedding", ""), ("regserver", ""), ("unregserver", "")]
+        )
+        self.assertEqual(args, ["spam", "foo", "blabla"])
+
+    def test_2(self):
+        args = "/TLB Hello.Tlb HELLO.idl".split()
+        opts, args = w_getopt(args, ["tlb:"])
+        self.assertEqual(opts, [("tlb", "Hello.Tlb")])
+        self.assertEqual(args, ["HELLO.idl"])
+
+    def test_3(self):
+        # Invalid option
+        self.assertRaises(
+            GetoptError, w_getopt, "/TLIB hello.tlb hello.idl".split(), ["tlb:"]
+        )
+
+    def test_4(self):
+        # Missing argument
+        self.assertRaises(GetoptError, w_getopt, "/TLB".split(), ["tlb:"])

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

@@ -1,19 +1,37 @@
 import unittest
-
-from ctypes import PyDLL, py_object, c_void_p, byref, POINTER
+from ctypes import POINTER, PyDLL, byref, c_void_p, py_object
 from ctypes.wintypes import BOOL
 
-from comtypes import IUnknown
+from comtypes import COMObject, IUnknown
+from comtypes.automation import VARIANT, IDispatch
 from comtypes.client import CreateObject
-from comtypes.automation import IDispatch
-from comtypes.test import requires
 
-requires("pythoncom")
 try:
     import pythoncom
     import win32com.client
 
-    skip = False
+    IMPORT_FAILED = False
+    # pywin32 is available.  The pythoncom dll contains two handy
+    # exported functions that allow to create a VARIANT from a Python
+    # object, also a function that unpacks a VARIANT into a Python
+    # object.
+    #
+    # This allows us to create und unpack SAFEARRAY instances
+    # contained in VARIANTs, and check for consistency with the
+    # comtypes code.
+    _dll = PyDLL(pythoncom.__file__)
+
+    # c:/sf/pywin32/com/win32com/src/oleargs.cpp 213
+    # PyObject *PyCom_PyObjectFromVariant(const VARIANT *var)
+    unpack = _dll.PyCom_PyObjectFromVariant
+    unpack.restype = py_object
+    unpack.argtypes = (POINTER(VARIANT),)
+
+    # c:/sf/pywin32/com/win32com/src/oleargs.cpp 54
+    # BOOL PyCom_VariantFromPyObject(PyObject *obj, VARIANT *var)
+    _pack = _dll.PyCom_VariantFromPyObject
+    _pack.argtypes = py_object, POINTER(VARIANT)
+    _pack.restype = BOOL
     # We use the PyCom_PyObjectFromIUnknown function in pythoncom25.dll to
     # convert a comtypes COM pointer into a pythoncom COM pointer.
     # Fortunately this function is exported by the dll...
@@ -30,17 +48,58 @@ except ImportError:
     # if it is available since pythoncom is not a project dependency and adding tests depending
     # on the vagaries of various testing environments is not deterministic.
     # TODO: Evaluate if we should just remove this test or what.
-    skip = True
+    IMPORT_FAILED = True
 
 
 def setUpModule():
-    if skip:
+    if IMPORT_FAILED:
         raise unittest.SkipTest(
             "This test requires the pythoncom library installed.  If this is "
             "important tests then we need to add dev dependencies to the project that include pythoncom."
         )
 
 
+################################################################
+
+
+def pack(obj):
+    var = VARIANT()
+    _pack(obj, byref(var))
+    return var
+
+
+class PyWinSafeArrayTest(unittest.TestCase):
+    def test_1dim(self):
+        data = (1, 2, 3)
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_2dim(self):
+        data = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_3dim(self):
+        data = (((1, 2), (3, 4), (5, 6)), ((7, 8), (9, 10), (11, 12)))
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_4dim(self):
+        data = (
+            (((1, 2), (3, 4)), ((5, 6), (7, 8))),
+            (((9, 10), (11, 12)), ((13, 14), (15, 16))),
+        )
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+
+################################################################
+
+
 def comtypes2pywin(ptr, interface=None):
     """Convert a comtypes pointer 'ptr' into a pythoncom
     PyI<interface> object.
@@ -56,9 +115,6 @@ def comtypes2pywin(ptr, interface=None):
     return _PyCom_PyObjectFromIUnknown(ptr, byref(interface._iid_), True)
 
 
-################################################################
-
-
 def comtypes_get_refcount(ptr):
     """Helper function for testing: return the COM reference count of
     a comtypes COM object"""
@@ -66,9 +122,6 @@ def comtypes_get_refcount(ptr):
     return ptr.Release()
 
 
-from comtypes import COMObject
-
-
 class MyComObject(COMObject):
     """A completely trivial COM object implementing IDispatch. Calling
     any methods will return the error code E_NOTIMPL (except the
@@ -77,42 +130,33 @@ class MyComObject(COMObject):
     _com_interfaces_ = [IDispatch]
 
 
-################################################################
-
-
-class Test(unittest.TestCase):
-    def tearDown(self):
-        if hasattr(self, "ie"):
-            self.ie.Quit()
-            del self.ie
-
+class ConvertComtypesPtrToPythonComObjTest(unittest.TestCase):
     def test_mycomobject(self):
         o = MyComObject()
         p = comtypes2pywin(o, IDispatch)
         disp = win32com.client.Dispatch(p)
         self.assertEqual(repr(disp), "<COMObject <unknown>>")
 
-    def test_ie(self):
-        # Convert a comtypes COM interface pointer into a win32com COM
-        # pointer.
-        ie = self.ie = CreateObject("InternetExplorer.Application")
+    def test_refcount(self):
+        # Convert a comtypes COM interface pointer into a win32com COM pointer.
+        dic = CreateObject("Scripting.Dictionary")
         # The COM refcount of the created object is 1:
-        self.assertEqual(comtypes_get_refcount(ie), 1)
-        # IE starts invisible:
-        self.assertEqual(ie.Visible, False)
+        self.assertEqual(comtypes_get_refcount(dic), 1)
+        dic["foo"] = "bar"
+        self.assertEqual(dic.Item("foo"), "bar")
 
         # Create a pythoncom PyIDispatch object from it:
-        p = comtypes2pywin(ie, interface=IDispatch)
-        self.assertEqual(comtypes_get_refcount(ie), 2)
+        p = comtypes2pywin(dic, interface=IDispatch)
+        self.assertEqual(comtypes_get_refcount(dic), 2)
 
         # Make it usable...
         disp = win32com.client.Dispatch(p)
-        self.assertEqual(comtypes_get_refcount(ie), 2)
-        self.assertEqual(disp.Visible, False)
+        self.assertEqual(comtypes_get_refcount(dic), 2)
+        self.assertEqual(disp.Item("foo"), "bar")
 
         # Cleanup and make sure that the COM refcounts are correct
         del p, disp
-        self.assertEqual(comtypes_get_refcount(ie), 1)
+        self.assertEqual(comtypes_get_refcount(dic), 1)
 
 
 if __name__ == "__main__":

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

@@ -1,9 +1,6 @@
 import unittest as ut
 
 from comtypes.client import CoGetObject
-from comtypes.test import requires
-
-requires("time")
 
 
 # WMI has dual interfaces.

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

@@ -1,8 +1,8 @@
 import time
 import unittest
 
-from comtypes import COMError
 import comtypes.client
+from comtypes import COMError
 
 try:
     comtypes.client.GetModule(