comtypes 1.4.8__zip → 1.4.10__zip

comtypes-1.4.10/comtypes/test/test_comserver.py

@@ -0,0 +1,349 @@
+import doctest
+import unittest
+from ctypes import pointer
+from typing import Any
+
+import comtypes.server
+import comtypes.test.TestComServer
+from comtypes import BSTR
+from comtypes.automation import VARIANT, _midlSAFEARRAY
+from comtypes.client import CreateObject, GetActiveObject
+from comtypes.server.register import register, unregister
+from comtypes.test.find_memleak import find_memleak
+
+try:
+    from win32com.client import Dispatch
+
+    IMPORT_PYWIN32_FAILED = False
+except ImportError:
+    IMPORT_PYWIN32_FAILED = True
+
+
+def setUpModule():
+    try:
+        register(comtypes.test.TestComServer.TestComServer)
+    except WindowsError as e:
+        if e.winerror != 5:  # [Error 5] Access is denied
+            raise e
+        raise unittest.SkipTest(
+            "This test requires the tests to be run as admin since it tries to "
+            "register the test COM server."
+        )
+
+
+def tearDownModule():
+    unregister(comtypes.test.TestComServer.TestComServer)
+
+
+class BaseServerTest(object):
+    def create_object(self) -> Any: ...
+
+    def _find_memleak(self, func):
+        bytes = find_memleak(func)
+        self.assertFalse(bytes, f"Leaks {bytes} bytes")  # type: ignore
+
+    def test_mixedinout(self):
+        o = self.create_object()
+        self.assertEqual(o.MixedInOut(2, 4), (3, 5))  # type: ignore
+
+    def test_getname(self):
+        # This tests a tricky bug, introduced with this patch:
+        # http://www.python.org/sf/1643874
+        #
+        # Returning a BSTR as an [out] parameter from a server
+        # implementation must transfer the ownership to the caller.
+        # When this is not done, the BSTR instance is SysFreeString'd
+        # too early, and the memory is reused.
+        obj = self.create_object()
+        pb = pointer(BSTR())
+        # Get the BSTR from the server:
+        obj._ITestComServer__com__get_name(pb)
+        # Retrieve the value, but keep the pointer to the BSTR alive:
+        name = pb[0]
+        # Create sme BSTR's to reuse the memory in case it has been freed:
+        for i in range(10):
+            BSTR("f" * len(name))
+        # Make sure the pointer is still valid:
+        self.assertEqual(pb[0], name)  # type: ignore
+
+    def test_get_id(self):
+        obj = self.create_object()
+        self._find_memleak(lambda: obj.id)
+
+    def test_get_name(self):
+        obj = self.create_object()
+        self._find_memleak(lambda: obj.name)
+
+    def test_set_name(self):
+        obj = self.create_object()
+
+        def func():
+            obj.name = "abcde"
+
+        self._find_memleak(func)
+
+    def test_SetName(self):
+        obj = self.create_object()
+
+        def func():
+            obj.SetName("abcde")
+
+        self._find_memleak(func)
+
+    def test_eval(self):
+        obj = self.create_object()
+
+        def func():
+            return obj.eval("(1, 2, 3)")
+
+        self.assertEqual(func(), (1, 2, 3))  # type: ignore
+        self._find_memleak(func)
+
+    def test_get_typeinfo(self):
+        obj = self.create_object()
+
+        def func():
+            obj.GetTypeInfo(0)
+            obj.GetTypeInfoCount()
+            obj.QueryInterface(comtypes.IUnknown)
+
+        self._find_memleak(func)
+
+
+class TestInproc(BaseServerTest, unittest.TestCase):
+    def create_object(self):
+        return CreateObject(
+            "TestComServerLib.TestComServer", clsctx=comtypes.CLSCTX_INPROC_SERVER
+        )
+
+
+class TestLocalServer(BaseServerTest, unittest.TestCase):
+    def create_object(self):
+        return CreateObject(
+            "TestComServerLib.TestComServer", clsctx=comtypes.CLSCTX_LOCAL_SERVER
+        )
+
+    @unittest.skip("This fails. Why?")
+    def test_get_typeinfo(self):
+        # Calling `GetTypeInfo` occurs;
+        # OSError: exception: access violation reading 0x0000000000000000
+        pass
+
+
+@unittest.skipIf(IMPORT_PYWIN32_FAILED, "This depends on 'pywin32'.")
+class TestInproc_win32com(BaseServerTest, unittest.TestCase):
+    def create_object(self):
+        return Dispatch("TestComServerLib.TestComServer")
+
+    # These tests make no sense with win32com, override to disable them:
+    @unittest.skip("This test make no sense with win32com.")
+    def test_get_typeinfo(self):
+        pass
+
+    @unittest.skip("This test make no sense with win32com.")
+    def test_getname(self):
+        pass
+
+    @unittest.skip("This test make no sense with win32com.")
+    def test_mixedinout(self):
+        # Not sure about this; it raise 'Invalid Number of parameters'
+        # Is mixed [in], [out] args not compatible with IDispatch???
+        pass
+
+
+@unittest.skipIf(IMPORT_PYWIN32_FAILED, "This depends on 'pywin32'.")
+class TestLocalServer_win32com(BaseServerTest, unittest.TestCase):
+    def create_object(self):
+        return Dispatch(
+            "TestComServerLib.TestComServer", clsctx=comtypes.CLSCTX_LOCAL_SERVER
+        )
+
+    # These tests are skipped for the same reason as `TestInproc_win32com`.
+    @unittest.skip("This test make no sense with win32com.")
+    def test_get_typeinfo(self):
+        pass
+
+    @unittest.skip("This test make no sense with win32com.")
+    def test_getname(self):
+        pass
+
+    @unittest.skip("This test make no sense with win32com.")
+    def test_mixedinout(self):
+        pass
+
+
+class ActiveObjTest(unittest.TestCase):
+    def get_active_object(self) -> comtypes.test.TestComServer.ITestComServer:
+        return GetActiveObject(
+            comtypes.test.TestComServer.TestComServer,
+            interface=comtypes.test.TestComServer.ITestComServer,
+        )
+
+    def _doit(self, weak: bool):
+        comobj = comtypes.test.TestComServer.TestComServer()
+        with self.assertRaises(OSError):
+            self.get_active_object()
+        handle = comtypes.server.RegisterActiveObject(comobj, weak=weak)
+        activeobj = self.get_active_object()
+        self.assertEqual(activeobj.MixedInOut(2, 4), (3, 5))
+        self.assertEqual(activeobj.AddRef(), 3)
+        self.assertEqual(activeobj.Release(), 2)
+        punk = comobj.QueryInterface(comtypes.test.TestComServer.ITestComServer)
+        self.assertEqual(activeobj, punk)
+        comtypes.server.RevokeActiveObject(handle)
+        with self.assertRaises(OSError):
+            self.get_active_object()
+
+    def test_activeobj_weak_registration(self):
+        self._doit(weak=True)
+
+    def test_activeobj_strong_registration(self):
+        self._doit(weak=False)
+
+
+class VariantTest(unittest.TestCase):
+    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, value.red)  # type: ignore
+        self.assertEqual(2.0, value.green)  # type: ignore
+        self.assertEqual(3.0, value.blue)  # type: ignore
+
+        def func():
+            v = VARIANT(MYCOLOR(red=1.0, green=2.0, blue=3.0))
+            return v.value
+
+        bytes = find_memleak(func)
+        self.assertFalse(bytes, f"Leaks {bytes} bytes")  # type: ignore
+
+
+class SafeArrayTest(unittest.TestCase):
+    def test_UDT(self):
+        from comtypes.gen.TestComServerLib import MYCOLOR
+
+        t = _midlSAFEARRAY(MYCOLOR)
+        self.assertTrue(t is _midlSAFEARRAY(MYCOLOR))
+
+        sa = t.from_param([MYCOLOR(0, 0, 0), MYCOLOR(1, 2, 3)])
+
+        self.assertEqual(
+            [(x.red, x.green, x.blue) for x in sa[0]],
+            [(0.0, 0.0, 0.0), (1.0, 2.0, 3.0)],
+        )
+
+        def doit():
+            t.from_param([MYCOLOR(0, 0, 0), MYCOLOR(1, 2, 3)])
+
+        bytes = find_memleak(doit)
+        self.assertFalse(bytes, f"Leaks {bytes} bytes")  # type: ignore
+
+
+class PropPutRefTest(unittest.TestCase):
+    def doit(self, dynamic: bool):
+        d = CreateObject("Scripting.Dictionary", dynamic=dynamic)
+        s = CreateObject("TestComServerLib.TestComServer", dynamic=dynamic)
+        s.name = "the value"
+
+        # This calls propputref, since we assign an Object
+        d.Item["object"] = s
+        # This calls propput, since we assing a Value
+        d.Item["value"] = s.name
+
+        self.assertEqual(d.Item["object"], s)
+        self.assertEqual(d.Item["object"].name, "the value")
+        self.assertEqual(d.Item["value"], "the value")
+
+        # Changing the default property of the object
+        s.name = "foo bar"
+        self.assertEqual(d.Item["object"], s)
+        self.assertEqual(d.Item["object"].name, "foo bar")
+        self.assertEqual(d.Item["value"], "the value")
+
+        # This also calls propputref since we assign an Object
+        d.Item["var"] = VARIANT(s)
+        self.assertEqual(d.Item["var"], s)
+
+    def test_earlybind(self):
+        self.doit(dynamic=False)
+
+    def test_latebind(self):
+        self.doit(dynamic=True)
+
+
+class TestEvents(unittest.TestCase):
+    def test(self):
+        import comtypes.test.test_comserver
+
+        doctest.testmod(
+            comtypes.test.test_comserver, verbose=False, optionflags=doctest.ELLIPSIS
+        )
+
+
+class ShowEventsExamples:
+    # The following functions are never called, they only contain doctests:
+
+    def ShowEventsFloat(self):
+        """
+        >>> from comtypes.client import CreateObject, ShowEvents
+        >>>
+        >>> o = CreateObject("TestComServerLib.TestComServer")
+        >>> con = ShowEvents(o)
+        # event found: ITestComServerEvents_EvalStarted
+        # event found: ITestComServerEvents_EvalCompleted
+        >>> result = o.eval("10. / 4")
+        Event ITestComServerEvents_EvalStarted(None, '10. / 4')
+        Event ITestComServerEvents_EvalCompleted(None, '10. / 4', VARIANT(vt=0x5, 2.5))
+        >>> result
+        2.5
+        >>>
+        """
+
+    # # The following test, if enabled, works but the testsuit
+    # # crashes elsewhere.  Is there s problem with SAFEARRAYs?
+
+    # def Fails(self):
+    #     """
+    #     >>> from comtypes.client import CreateObject, ShowEvents
+    #     >>>
+    #     >>> o = CreateObject("TestComServerLib.TestComServer")
+    #     >>> con = ShowEvents(o)
+    #     # event found: ITestComServerEvents_EvalStarted
+    #     # event found: ITestComServerEvents_EvalCompleted
+    #     >>> result = o.eval("['32'] * 2")
+    #     Event ITestComServerEvents_EvalStarted(None, u"['32'] * 2")
+    #     Event ITestComServerEvents_EvalCompleted(None, u"['32'] * 2", VARIANT(vt=0x200c, (u'32', u'32')))
+    #     >>> result
+    #     (u'32', u'32')
+    #     >>>
+    #     """
+
+    def GetEvents(self):
+        """
+        >>> from comtypes.client import CreateObject, GetEvents
+        >>>
+        >>> o =  CreateObject("TestComServerLib.TestComServer")
+        >>> class EventHandler(object):
+        ...     def EvalStarted(self, this, what):
+        ...         print("EvalStarted: %s" % what)
+        ...         return 0
+        ...     def EvalCompleted(self, this, what, result):
+        ...         print("EvalCompleted: %s = %s" % (what, result.value))
+        ...         return 0
+        ...
+        >>>
+        >>> con = GetEvents(o, EventHandler())
+        >>> o.eval("2 + 3")
+        EvalStarted: 2 + 3
+        EvalCompleted: 2 + 3 = 5
+        5
+        >>> del con
+        >>> o.eval("3 + 2")
+        5
+        >>>
+        """
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -15,8 +15,6 @@ def setUpModule():
     )
 
 
-# requires("typelibs")
-
 # filter warnings about interfaces without a base interface; they will
 # be skipped in the code generation.
 warnings.filterwarnings(
@@ -57,8 +55,8 @@ def add_test(fname):
             return
         comtypes.client.GetModule(fname)
 
-    test.__doc__ = "test GetModule(%r)" % fname
-    setattr(Test, "test_%d" % number, test)
+    test.__doc__ = f"test GetModule({fname!r})"
+    setattr(Test, f"test_{number}", test)
     number += 1
 
 

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

@@ -1,10 +1,10 @@
 # coding: utf-8
 
 import unittest
+from ctypes import byref, pointer
 
 from comtypes import CLSCTX_LOCAL_SERVER
 from comtypes.client import CreateObject, GetModule
-from ctypes import byref, pointer
 
 ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
 

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

@@ -1,7 +1,7 @@
 # coding: utf-8
 
-from ctypes import byref, c_double, pointer
 import unittest
+from ctypes import byref, c_double, pointer
 
 import comtypes
 import comtypes.safearray

comtypes-1.4.10/comtypes/test/test_dispinterface.py

@@ -0,0 +1,153 @@
+import os
+import unittest
+
+import comtypes.test.TestDispServer
+from comtypes.server.register import register, unregister
+
+try:
+    from win32com.client import Dispatch
+    from win32com.client.gencache import EnsureDispatch
+
+    IMPORT_PYWIN32_FAILED = False
+except ImportError:
+    IMPORT_PYWIN32_FAILED = True
+
+
+def setUpModule():
+    try:
+        register(comtypes.test.TestDispServer.TestDispServer)
+    except WindowsError as e:
+        if e.winerror != 5:  # [Error 5] Access is denied
+            raise e
+        raise unittest.SkipTest(
+            "This test requires the tests to be run as admin since it tries to "
+            "register the test COM server."
+        )
+
+
+def tearDownModule():
+    unregister(comtypes.test.TestDispServer.TestDispServer)
+
+
+@unittest.skipIf(IMPORT_PYWIN32_FAILED, "This depends on 'pywin32'.")
+class Test_win32com(unittest.TestCase):
+    @unittest.skip(
+        "It likely fails due to bugs in `GenerateChildFromTypeLibSpec` "
+        "or `GetModuleForCLSID`."
+    )
+    def test_win32com_ensure_dispatch(self):
+        # EnsureDispatch is case-sensitive
+        d = EnsureDispatch("TestDispServerLib.TestDispServer")
+
+        self.assertEqual(d.eval("3.14"), 3.14)
+        self.assertEqual(d.eval("1 + 2"), 3)
+        self.assertEqual(d.eval("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        self.assertEqual(d.eval2("3.14"), 3.14)
+        self.assertEqual(d.eval2("1 + 2"), 3)
+        self.assertEqual(d.eval2("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        d.eval(
+            "__import__('comtypes.client').client.CreateObject('Scripting.Dictionary')"
+        )
+
+        server_id = d.eval("id(self)")
+        self.assertEqual(d.id, server_id)
+
+        self.assertEqual(d.name, "spam, spam, spam")
+
+        d.SetName("foo bar")
+        self.assertEqual(d.name, "foo bar")
+
+        d.name = "blah"
+        self.assertEqual(d.name, "blah")
+
+    def test_win32com_dynamic_dispatch(self):
+        # dynamic Dispatch is case-IN-sensitive
+        d = Dispatch("TestDispServerLib.TestDispServer")
+
+        self.assertEqual(d.eval("3.14"), 3.14)
+        self.assertEqual(d.eval("1 + 2"), 3)
+        self.assertEqual(d.eval("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        self.assertEqual(d.eval2("3.14"), 3.14)
+        self.assertEqual(d.eval2("1 + 2"), 3)
+        self.assertEqual(d.eval2("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        d.eval(
+            "__import__('comtypes.client').client.CreateObject('Scripting.Dictionary')"
+        )
+
+        self.assertEqual(d.EVAL("3.14"), 3.14)
+        self.assertEqual(d.EVAL("1 + 2"), 3)
+        self.assertEqual(d.EVAL("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        self.assertEqual(d.EVAL2("3.14"), 3.14)
+        self.assertEqual(d.EVAL2("1 + 2"), 3)
+        self.assertEqual(d.EVAL2("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        server_id = d.eval("id(self)")
+        self.assertEqual(d.id, server_id)
+        self.assertEqual(d.ID, server_id)
+
+        self.assertEqual(d.Name, "spam, spam, spam")
+        self.assertEqual(d.nAME, "spam, spam, spam")
+
+        d.SetName("foo bar")
+        self.assertEqual(d.Name, "foo bar")
+
+        # fails.  Why?
+        # d.name = "blah"
+        # self.assertEqual(d.Name, "blah")
+
+
+class Test_comtypes(unittest.TestCase):
+    def test_comtypes(self):
+        from comtypes.client import CreateObject
+
+        d = CreateObject("TestDispServerLib.TestDispServer")
+
+        self.assertEqual(d.eval("3.14"), 3.14)
+        self.assertEqual(d.eval("1 + 2"), 3)
+        self.assertEqual(d.eval("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        self.assertEqual(d.eval2("3.14"), 3.14)
+        self.assertEqual(d.eval2("1 + 2"), 3)
+        self.assertEqual(d.eval2("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        d.eval(
+            "__import__('comtypes.client').client.CreateObject('Scripting.Dictionary')"
+        )
+
+        self.assertEqual(d.EVAL("3.14"), 3.14)
+        self.assertEqual(d.EVAL("1 + 2"), 3)
+        self.assertEqual(d.EVAL("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        self.assertEqual(d.EVAL2("3.14"), 3.14)
+        self.assertEqual(d.EVAL2("1 + 2"), 3)
+        self.assertEqual(d.EVAL2("[1 + 2, 'foo', None]"), (3, "foo", None))
+
+        server_id = d.eval("id(self)")
+        self.assertEqual(d.id, server_id)
+        self.assertEqual(d.ID, server_id)
+
+        self.assertEqual(d.Name, "spam, spam, spam")
+        self.assertEqual(d.nAME, "spam, spam, spam")
+
+        d.SetName("foo bar")
+        self.assertEqual(d.Name, "foo bar")
+
+        d.name = "blah"
+        self.assertEqual(d.Name, "blah")
+
+
+@unittest.skip("This raises 'ClassFactory cannot supply requested class'. Why?")
+class Test_jscript(unittest.TestCase):
+    def test_withjscript(self):
+        jscript = os.path.join(os.path.dirname(__file__), "test_jscript.js")
+        errcode = os.system("cscript -nologo %s" % jscript)
+        self.assertEqual(errcode, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -1,4 +1,5 @@
 import unittest
+
 from comtypes.automation import IDispatch
 from comtypes.client import CreateObject, GetModule
 from comtypes.client.lazybind import Dispatch

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

@@ -3,6 +3,7 @@
 import datetime
 import sys
 import unittest
+from typing import ClassVar
 
 from comtypes.client import CreateObject, GetModule
 
@@ -27,6 +28,7 @@ except (ImportError, OSError):
 
 class BaseBindTest(object):
     # `dynamic = True/False` must be defined in subclasses!
+    dynamic: ClassVar[bool]
 
     def setUp(self):
         self.xl = CreateObject("Excel.Application", dynamic=self.dynamic)
@@ -62,17 +64,21 @@ class BaseBindTest(object):
         # call property to retrieve value
         expected_values = ((10.0, 20.0, 31.4), ("x", "y", "z"), (3.0, 2.0, 1.0))
         # XXX: in Python >= 3.8.x, fails below
-        self.assertEqual(xl.Range["A1:C3"].Value(), expected_values)
+        self.assertEqual(xl.Range["A1:C3"].Value(), expected_values)  # type: ignore
         # index with empty tuple
-        self.assertEqual(xl.Range["A1:C3"].Value[()], expected_values)
+        self.assertEqual(xl.Range["A1:C3"].Value[()], expected_values)  # type: ignore
         # index with empty slice
-        self.assertEqual(xl.Range["A1:C3"].Value[:], expected_values)
-        self.assertEqual(xl.Range["A1:C3"].Value[xlRangeValueDefault], expected_values)
-        self.assertEqual(xl.Range["A1", "C3"].Value[()], expected_values)
+        self.assertEqual(xl.Range["A1:C3"].Value[:], expected_values)  # type: ignore
+        self.assertEqual(  # type: ignore
+            xl.Range["A1:C3"].Value[xlRangeValueDefault], expected_values
+        )
+        self.assertEqual(  # type: ignore
+            xl.Range["A1", "C3"].Value[()], expected_values
+        )
 
         # Test for iteration support in "Range" interface
         iter(xl.Range["A1:C3"])
-        self.assertEqual(
+        self.assertEqual(  # type: ignore
             [c.Value() for c in xl.Range["A1:C3"]],
             [10.0, 20.0, 31.4, "x", "y", "z", 3.0, 2.0, 1.0],
         )
@@ -83,25 +89,29 @@ class BaseBindTest(object):
         for i in range(20):
             val = "Hi %d" % i
             xl.Cells.Item[i + 1, i + 1].Value[()] = val
-            self.assertEqual(xl.Cells.Item[i + 1, i + 1].Value[()], val)
+            self.assertEqual(  # type: ignore
+                xl.Cells.Item[i + 1, i + 1].Value[()], val
+            )
 
         for i in range(20):
             val = "Hi %d" % i
             xl.Cells(i + 1, i + 1).Value[()] = val
-            self.assertEqual(xl.Cells(i + 1, i + 1).Value[()], val)
+            self.assertEqual(xl.Cells(i + 1, i + 1).Value[()], val)  # type: ignore
 
         # test dates out with Excel
         xl.Range["A5"].Value[()] = "Excel time"
         xl.Range["B5"].Formula = "=Now()"
-        self.assertEqual(xl.Cells.Item[5, 2].Formula, "=NOW()")
+        self.assertEqual(xl.Cells.Item[5, 2].Formula, "=NOW()")  # type: ignore
 
         xl.Range["A6"].Calculate()
         excel_time = xl.Range["B5"].Value[()]
-        self.assertEqual(type(excel_time), datetime.datetime)
+        self.assertEqual(type(excel_time), datetime.datetime)  # type: ignore
         python_time = datetime.datetime.now()
 
-        self.assertTrue(python_time >= excel_time)
-        self.assertTrue(python_time - excel_time < datetime.timedelta(seconds=1))
+        self.assertTrue(python_time >= excel_time)  # type: ignore
+        self.assertTrue(  # type: ignore
+            python_time - excel_time < datetime.timedelta(seconds=1)
+        )
 
         # some random code, grabbed from c.l.p
         sh = wb.Worksheets[1]

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

@@ -4,15 +4,14 @@ import os
 import sys
 import tempfile
 import types
-from typing import Iterator
 import unittest
+from typing import Iterator
 from unittest import mock
 
 import comtypes
 import comtypes.client
 import comtypes.gen
 
-
 IMGBASE = os.path.splitext(os.path.basename(sys.executable))[0]
 
 

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

@@ -8,9 +8,9 @@ import comtypes.test
 try:
     # pass Word libUUID
     comtypes.client.GetModule(("{00020905-0000-0000-C000-000000000046}",))
-    IMPORT_FAILED = False
+    IMPORT_WORD_FAILED = False
 except (ImportError, OSError):
-    IMPORT_FAILED = True
+    IMPORT_WORD_FAILED = True
 
 
 ################################################################
@@ -24,8 +24,8 @@ except (ImportError, OSError):
 ################################################################
 
 
-@unittest.skipIf(IMPORT_FAILED, "This depends on Word.")
-class Test(unittest.TestCase):
+@unittest.skipIf(IMPORT_WORD_FAILED, "This depends on Word.")
+class Test_Word(unittest.TestCase):
     def setUp(self):
         try:
             comtypes.client.GetActiveObject("Word.Application")