Maybe actually fix tests

Author: Avasam

com/win32com/test/testArrays.py

@@ -1,11 +1,15 @@
 # Originally contributed by Stefan Schukat as part of this arbitrary-sized
 # arrays patch.
+from __future__ import annotations
+
+import platform
+import unittest
 
 from win32com.client import gencache
 from win32com.test import util
 
 ZeroD = 0
-OneDEmpty = []
+OneDEmpty: list[int] = []
 OneD = [1, 2, 3]
 TwoD = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
 
@@ -48,7 +52,12 @@ def _normalize_array(a):
         ret.append(_normalize_array(i))
     return ret
 
-
+@unittest.skipIf(
+    platform.machine() == "ARM64",
+    "PyCOMTest.ArrayTest cannot currently be run on ARM64 "
+    + "due to lacking win32com.universal implementation "
+    + "in com/win32com/src/univgw.cpp",
+)
 class ArrayTest(util.TestCase):
     def setUp(self):
         self.arr = gencache.EnsureDispatch("PyCOMTest.ArrayTest", bForDemand=False)

com/win32com/test/testPyComTest.py

@@ -7,17 +7,14 @@
 import datetime
 import decimal
 import os
-import platform
 import time
-from unittest import SkipTest
 
 import pythoncom
 import win32com
 import win32com.test.util
 import win32timezone
 import winerror
 from win32api import CloseHandle, GetCurrentProcessId, OpenProcess
-from win32com import universal
 from win32com.client import (
     VARIANT,
     CastTo,
@@ -174,7 +171,7 @@ def _DumpFireds(self):
         if not self.fireds:
             print("ERROR: Nothing was received!")
         for firedId, no in self.fireds.items():
-            progress("ID %d fired %d times" % (firedId, no))
+            progress(f"ID {firedId} fired {no} times")
 
 
 # Test everything which can be tested using both the "dynamic" and "generated"
@@ -890,36 +887,29 @@ def TestVTableMI():
         pass
 
 
-def TestQueryInterface(long_lived_server=0, iterations=5):
+def TestQueryInterface(long_lived_server: bool = False, iterations=5):
     tester = win32com.client.Dispatch("PyCOMTest.PyCOMTest")
     if long_lived_server:
         # Create a local server
         t0 = win32com.client.Dispatch(
             "Python.Test.PyCOMTest", clsctx=pythoncom.CLSCTX_LOCAL_SERVER
         )
-    # Request custom interfaces a number of times
-    prompt = [
-        "Testing QueryInterface without long-lived local-server #%d of %d...",
-        "Testing QueryInterface with long-lived local-server #%d of %d...",
-    ]
+    # Request custom interfaces a number of time
 
     for i in range(iterations):
-        progress(prompt[long_lived_server != 0] % (i + 1, iterations))
+        progress(
+            f"Testing QueryInterface "
+            + ("with" if long_lived_server else "without")
+            + f" long-lived local-server #{i + 1} of {iterations}..."
+        )
         tester.TestQueryInterface()
 
 
 class Tester(win32com.test.util.TestCase):
     def testRegisterInterfacesAfterGencache(self) -> None:
         # We had a bug where RegisterInterfaces would fail if gencache had
         # already been run - exercise that here
-        try:
-            RegisterInterfaces("{6BCDCB60-5605-11D0-AE5F-CADD4C000000}", 0, 1, 1)
-        except NotImplementedError:
-            if platform.machine() == "ARM64":
-                raise SkipTest(
-                    "`win32com.universal.RegisterInterfaces` doesn't support ARM64 yet"
-                )
-            raise
+        RegisterInterfaces("{6BCDCB60-5605-11D0-AE5F-CADD4C000000}", 0, 1, 1)
 
     def testVTableInProc(self) -> None:
         # We used to crash running this the second time - do it a few times
@@ -941,15 +931,15 @@ def testVTableMI(self):
             TestVTableMI()
 
     def testMultiQueryInterface(self):
-        TestQueryInterface(0, 6)
+        TestQueryInterface(False, 6)
         # When we use the custom interface in the presence of a long-lived
         # local server, i.e. a local server that is already running when
         # we request an instance of our COM object, and remains afterwards,
         # then after repeated requests to create an instance of our object
         # the custom interface disappears -- i.e. QueryInterface fails with
         # E_NOINTERFACE. Set the upper range of the following test to 2 to
-        # pass this test, i.e. TestQueryInterface(1,2)
-        TestQueryInterface(1, 6)
+        # pass this test, i.e. TestQueryInterface(True, 2)
+        TestQueryInterface(True, 6)
 
     def testDynamic(self):
         TestDynamic()

com/win32com/test/testall.py

@@ -52,7 +52,7 @@ def CleanGenerated():
 
     if os.path.isdir(win32com.__gen_path__):
         if verbosity > 1:
-            print("Deleting files from %s" % (win32com.__gen_path__))
+            print(f"Deleting files from", win32com.__gen_path__)
         shutil.rmtree(win32com.__gen_path__)
     import win32com.client.gencache
 
@@ -78,17 +78,20 @@ def ExecuteSilentlyIfOK(cmd, testcase):
     rc = f.close()
     if rc:
         print(data)
-        testcase.fail("Executing '%s' failed (%d)" % (cmd, rc))
+        testcase.fail(f"Executing '{cmd}' failed ({rc})")
     # for "_d" builds, strip the '[xxx refs]' line
     return RemoveRefCountOutput(data)
 
 
+@unittest.skipIf(
+    platform.machine() == "ARM64",
+    "PyCOMTest cannot currently be run on ARM64 "
+    + "due to lacking win32com.universal implementation "
+    + "in com/win32com/src/univgw.cpp",
+)
 class PyCOMTest(TestCase):
     no_leak_tests = True  # done by the test itself
 
-    @unittest.skipIf(
-        platform.machine() == "ARM64", "PyCOMTest cannot currently be run on ARM64"
-    )
     def testit(self):
         # Check that the item is registered, so we get the correct
         # 'skipped' behaviour (and recorded as such) rather than either
@@ -294,8 +297,7 @@ def usage(why):
             print("These tests may take *many* minutes to run - be patient!")
             print("(running from python.exe will avoid these leak tests)")
         print(
-            "Executing level %d tests - %d test cases will be run"
-            % (testLevel, suite.countTestCases())
+            f"Executing level {testLevel} tests - {suite.countTestCases()} test cases will be run"
         )
         if verbosity == 1 and suite.countTestCases() < 70:
             # A little row of markers so the dots show how close to finished
@@ -310,7 +312,7 @@ def usage(why):
             desc = "\n".join(traceback.format_exception_only(exc_type, exc_val))
             testResult.stream.write(f"{mod_name}: {desc}")
         testResult.stream.writeln(
-            "*** %d test(s) could not be run ***" % len(import_failures)
+            f"*** {len(import_failures)} test(s) could not be run ***"
         )
 
     # re-print unit-test error here so it is noticed