lsst-utils 25.2023.600__py3-none-any.whl → 29.2025.4800__py3-none-any.whl

lsst/utils/tests.py

@@ -9,19 +9,22 @@
 # Use of this source code is governed by a 3-clause BSD-style
 # license that can be found in the LICENSE file.
 
-"""Support code for running unit tests"""
+"""Support code for running unit tests."""
+
+from __future__ import annotations
 
 __all__ = [
-    "init",
-    "MemoryTestCase",
     "ExecutablesTestCase",
-    "getTempFilePath",
+    "ImportTestCase",
+    "MemoryTestCase",
     "TestCase",
     "assertFloatsAlmostEqual",
-    "assertFloatsNotEqual",
     "assertFloatsEqual",
-    "debugger",
+    "assertFloatsNotEqual",
     "classParameters",
+    "debugger",
+    "getTempFilePath",
+    "init",
     "methodParameters",
     "temporaryDirectory",
 ]
@@ -32,22 +35,27 @@ import gc
 import inspect
 import itertools
 import os
+import re
 import shutil
 import subprocess
 import sys
 import tempfile
 import unittest
 import warnings
-from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Sequence, Set, Type, Union
+from collections.abc import Callable, Container, Iterable, Iterator, Mapping, Sequence
+from importlib import resources
+from typing import Any, ClassVar
 
 import numpy
 import psutil
 
+from .doImport import doImport
+
 # Initialize the list of open files to an empty set
 open_files = set()
 
 
-def _get_open_files() -> Set[str]:
+def _get_open_files() -> set[str]:
     """Return a set containing the list of files currently open in this
     process.
 
@@ -56,7 +64,7 @@ def _get_open_files() -> Set[str]:
     open_files : `set`
         Set containing the list of open files.
     """
-    return set(p.path for p in psutil.Process().open_files())
+    return {p.path for p in psutil.Process().open_files()}
 
 
 def init() -> None:
@@ -108,47 +116,57 @@ def sort_tests(tests) -> unittest.TestSuite:
     return suite
 
 
-def suiteClassWrapper(tests):
+def _suiteClassWrapper(tests):
     return unittest.TestSuite(sort_tests(tests))
 
 
 # Replace the suiteClass callable in the defaultTestLoader
 # so that we can reorder the test ordering. This will have
 # no effect if no memory test cases are found.
-unittest.defaultTestLoader.suiteClass = suiteClassWrapper
+unittest.defaultTestLoader.suiteClass = _suiteClassWrapper
 
 
 class MemoryTestCase(unittest.TestCase):
     """Check for resource leaks."""
 
+    ignore_regexps: ClassVar[list[str]] = []
+    """List of regexps to ignore when checking for open files."""
+
     @classmethod
     def tearDownClass(cls) -> None:
-        """Reset the leak counter when the tests have been completed"""
+        """Reset the leak counter when the tests have been completed."""
         init()
 
     def testFileDescriptorLeaks(self) -> None:
-        """Check if any file descriptors are open since init() called."""
+        """Check if any file descriptors are open since init() called.
+
+        Ignores files with certain known path components and any files
+        that match regexp patterns in class property ``ignore_regexps``.
+        """
         gc.collect()
         global open_files
         now_open = _get_open_files()
 
         # Some files are opened out of the control of the stack.
-        now_open = set(
+        now_open = {
             f
             for f in now_open
             if not f.endswith(".car")
             and not f.startswith("/proc/")
+            and not f.startswith("/sys/")
             and not f.endswith(".ttf")
             and not (f.startswith("/var/lib/") and f.endswith("/passwd"))
             and not f.endswith("astropy.log")
             and not f.endswith("mime/mime.cache")
-        )
+            and not f.endswith(".sqlite3")
+            and not any(re.search(r, f) for r in self.ignore_regexps)
+        }
 
         diff = now_open.difference(open_files)
         if diff:
             for f in diff:
-                print("File open: %s" % f)
-            self.fail("Failed to close %d file%s" % (len(diff), "s" if len(diff) != 1 else ""))
+                print(f"File open: {f}")
+            self.fail(f"Failed to close {len(diff)} file{'s' if len(diff) != 1 else ''}")
 
 
 class ExecutablesTestCase(unittest.TestCase):
@@ -174,14 +192,13 @@ class ExecutablesTestCase(unittest.TestCase):
         executed. This allows the test runner to trigger the class set up
         machinery to test whether there are some executables to test.
         """
-        pass
 
     def assertExecutable(
         self,
         executable: str,
-        root_dir: Optional[str] = None,
-        args: Optional[Sequence[str]] = None,
-        msg: Optional[str] = None,
+        root_dir: str | None = None,
+        args: Sequence[str] | None = None,
+        msg: str | None = None,
     ) -> None:
         """Check an executable runs and returns good status.
 
@@ -216,15 +233,15 @@ class ExecutablesTestCase(unittest.TestCase):
             sp_args.extend(args)
             argstr = 'arguments "' + " ".join(args) + '"'
 
-        print("Running executable '{}' with {}...".format(executable, argstr))
+        print(f"Running executable '{executable}' with {argstr}...")
         if not os.path.exists(executable):
-            self.skipTest("Executable {} is unexpectedly missing".format(executable))
+            self.skipTest(f"Executable {executable} is unexpectedly missing")
         failmsg = None
         try:
             output = subprocess.check_output(sp_args)
         except subprocess.CalledProcessError as e:
             output = e.output
-            failmsg = "Bad exit status from '{}': {}".format(executable, e.returncode)
+            failmsg = f"Bad exit status from '{executable}': {e.returncode}"
         print(output.decode("utf-8"))
         if failmsg:
             if msg is None:
@@ -264,7 +281,7 @@ class ExecutablesTestCase(unittest.TestCase):
         setattr(cls, test_name, test_executable_runs)
 
     @classmethod
-    def create_executable_tests(cls, ref_file: str, executables: Optional[Sequence[str]] = None) -> None:
+    def create_executable_tests(cls, ref_file: str, executables: Sequence[str] | None = None) -> None:
         """Discover executables to test and create corresponding test methods.
 
         Scans the directory containing the supplied reference file
@@ -300,7 +317,7 @@ class ExecutablesTestCase(unittest.TestCase):
         if executables is None:
             # Look for executables to test by walking the tree
             executables = []
-            for root, dirs, files in os.walk(ref_dir):
+            for root, _, files in os.walk(ref_dir):
                 for f in files:
                     # Skip Python files. Shared libraries are executable.
                     if not f.endswith(".py") and not f.endswith(".so"):
@@ -319,10 +336,85 @@ class ExecutablesTestCase(unittest.TestCase):
             cls._build_test_method(e, ref_dir)
 
 
+class ImportTestCase(unittest.TestCase):
+    """Test that the named packages can be imported and all files within
+    that package.
+
+    The test methods are created dynamically. Callers must subclass this
+    method and define the ``PACKAGES`` property.
+    """
+
+    PACKAGES: ClassVar[Iterable[str]] = ()
+    """Packages to be imported."""
+
+    SKIP_FILES: ClassVar[Mapping[str, Container[str]]] = {}
+    """Files to be skipped importing; specified as key-value pairs.
+
+    The key is the package name and the value is a set of files names in that
+    package to skip.
+
+    Note: Files with names not ending in .py or beginning with leading double
+    underscores are always skipped.
+    """
+
+    _n_registered = 0
+    """Number of packages registered for testing by this class."""
+
+    def _test_no_packages_registered_for_import_testing(self) -> None:
+        """Test when no packages have been registered.
+
+        Without this, if no packages have been listed no tests will be
+        registered and the test system will not report on anything. This
+        test fails and reports why.
+        """
+        raise AssertionError("No packages registered with import test. Was the PACKAGES property set?")
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Create the test methods based on the content of the ``PACKAGES``
+        class property.
+        """
+        super().__init_subclass__(**kwargs)
+
+        for mod in cls.PACKAGES:
+            test_name = "test_import_" + mod.replace(".", "_")
+
+            def test_import(*args: Any, mod=mod) -> None:
+                self = args[0]
+                self.assertImport(mod)
+
+            test_import.__name__ = test_name
+            setattr(cls, test_name, test_import)
+            cls._n_registered += 1
+
+        # If there are no packages listed that is likely a mistake and
+        # so register a failing test.
+        if cls._n_registered == 0:
+            cls.test_no_packages_registered = cls._test_no_packages_registered_for_import_testing
+
+    def assertImport(self, root_pkg):
+        for file in resources.files(root_pkg).iterdir():
+            file = file.name
+            # When support for python 3.9 is dropped, this could be updated to
+            # use match case construct.
+            if not file.endswith(".py"):
+                continue
+            if file.startswith("__"):
+                continue
+            if file in self.SKIP_FILES.get(root_pkg, ()):
+                continue
+            root, _ = os.path.splitext(file)
+            module_name = f"{root_pkg}.{root}"
+            with self.subTest(module=module_name):
+                try:
+                    doImport(module_name)
+                except ImportError as e:
+                    raise AssertionError(f"Error importing module {module_name}: {e}") from e
+
+
 @contextlib.contextmanager
 def getTempFilePath(ext: str, expectOutput: bool = True) -> Iterator[str]:
     """Return a path suitable for a temporary file and try to delete the
-    file on success
+    file on success.
 
     If the with block completes successfully then the file is deleted,
     if possible; failure results in a printed warning.
@@ -342,11 +434,11 @@ def getTempFilePath(ext: str, expectOutput: bool = True) -> Iterator[str]:
         If `False`, a file should not be present when the context manager
         exits.
 
-    Returns
-    -------
+    Yields
+    ------
     path : `str`
         Path for a temporary file. The path is a combination of the caller's
-        file path and the name of the top-level function
+        file path and the name of the top-level function.
 
     Examples
     --------
@@ -355,6 +447,8 @@ def getTempFilePath(ext: str, expectOutput: bool = True) -> Iterator[str]:
         # file tests/testFoo.py
         import unittest
         import lsst.utils.tests
+
+
         class FooTestCase(unittest.TestCase):
             def testBasics(self):
                 self.runTest()
@@ -368,6 +462,8 @@ def getTempFilePath(ext: str, expectOutput: bool = True) -> Iterator[str]:
                     # at the end of this "with" block the path tmpFile will be
                     # deleted, but only if the file exists and the "with"
                     # block terminated normally (rather than with an exception)
+
+
         ...
     """
     stack = inspect.stack()
@@ -387,29 +483,31 @@ def getTempFilePath(ext: str, expectOutput: bool = True) -> Iterator[str]:
     callerFileName = os.path.splitext(callerFileNameWithExt)[0]
     outDir = os.path.join(callerDir, ".tests")
     if not os.path.isdir(outDir):
-        outDir = ""
-    prefix = "%s_%s-" % (callerFileName, callerFuncName)
+        # No .tests directory implies we are not running with sconsUtils.
+        # Need to use the current working directory, the callerDir, or
+        # /tmp equivalent. If cwd is used if must be as an absolute path
+        # in case the test code changes cwd.
+        outDir = os.path.abspath(os.path.curdir)
+    prefix = f"{callerFileName}_{callerFuncName}-"
     outPath = tempfile.mktemp(dir=outDir, suffix=ext, prefix=prefix)
     if os.path.exists(outPath):
         # There should not be a file there given the randomizer. Warn and
         # remove.
         # Use stacklevel 3 so that the warning is reported from the end of the
         # with block
-        warnings.warn("Unexpectedly found pre-existing tempfile named %r" % (outPath,), stacklevel=3)
-        try:
+        warnings.warn(f"Unexpectedly found pre-existing tempfile named {outPath!r}", stacklevel=3)
+        with contextlib.suppress(OSError):
             os.remove(outPath)
-        except OSError:
-            pass
 
     yield outPath
 
     fileExists = os.path.exists(outPath)
     if expectOutput:
         if not fileExists:
-            raise RuntimeError("Temp file expected named {} but none found".format(outPath))
+            raise RuntimeError(f"Temp file expected named {outPath} but none found")
     else:
         if fileExists:
-            raise RuntimeError("Unexpectedly discovered temp file named {}".format(outPath))
+            raise RuntimeError(f"Unexpectedly discovered temp file named {outPath}")
     # Try to clean up the file regardless
     if fileExists:
         try:
@@ -417,7 +515,7 @@ def getTempFilePath(ext: str, expectOutput: bool = True) -> Iterator[str]:
         except OSError as e:
             # Use stacklevel 3 so that the warning is reported from the end of
             # the with block.
-            warnings.warn("Warning: could not remove file %r: %s" % (outPath, e), stacklevel=3)
+            warnings.warn(f"Warning: could not remove file {outPath!r}: {e}", stacklevel=3)
 
 
 class TestCase(unittest.TestCase):
@@ -429,13 +527,23 @@ class TestCase(unittest.TestCase):
 def inTestCase(func: Callable) -> Callable:
     """Add a free function to our custom TestCase class, while
     also making it available as a free function.
+
+    Parameters
+    ----------
+    func : `~collections.abc.Callable`
+        Function to be added to `unittest.TestCase` class.
+
+    Returns
+    -------
+    func : `~collections.abc.Callable`
+        The given function.
     """
     setattr(TestCase, func.__name__, func)
     return func
 
 
 def debugger(*exceptions):
-    """Enter the debugger when there's an uncaught exception
+    """Enter the debugger when there's an uncaught exception.
 
     To use, just slap a ``@debugger()`` on your function.
 
@@ -448,6 +556,12 @@ def debugger(*exceptions):
     Code provided by "Rosh Oxymoron" on StackOverflow:
     http://stackoverflow.com/questions/4398967/python-unit-testing-automatically-running-the-debugger-when-a-test-fails
 
+    Parameters
+    ----------
+    *exceptions : `Exception`
+        Specific exception classes to catch. Default is to catch
+        `AssertionError`.
+
     Notes
     -----
     Consider using ``pytest --pdb`` instead of this decorator.
@@ -474,22 +588,22 @@ def debugger(*exceptions):
 def plotImageDiff(
     lhs: numpy.ndarray,
     rhs: numpy.ndarray,
-    bad: Optional[numpy.ndarray] = None,
-    diff: Optional[numpy.ndarray] = None,
-    plotFileName: Optional[str] = None,
+    bad: numpy.ndarray | None = None,
+    diff: numpy.ndarray | None = None,
+    plotFileName: str | None = None,
 ) -> None:
     """Plot the comparison of two 2-d NumPy arrays.
 
     Parameters
     ----------
     lhs : `numpy.ndarray`
-        LHS values to compare; a 2-d NumPy array
+        LHS values to compare; a 2-d NumPy array.
     rhs : `numpy.ndarray`
-        RHS values to compare; a 2-d NumPy array
+        RHS values to compare; a 2-d NumPy array.
     bad : `numpy.ndarray`
-        A 2-d boolean NumPy array of values to emphasize in the plots
+        A 2-d boolean NumPy array of values to emphasize in the plots.
     diff : `numpy.ndarray`
-        difference array; a 2-d NumPy array, or None to show lhs-rhs
+        Difference array; a 2-d NumPy array, or None to show lhs-rhs.
     plotFileName : `str`
         Filename to save the plot to.  If None, the plot will be displayed in
         a window.
@@ -500,11 +614,20 @@ def plotImageDiff(
     wrapped in a try/except block within packages that do not depend on
     `matplotlib` (including `~lsst.utils`).
     """
-    from matplotlib import pyplot
+    if plotFileName is None:
+        # We need to create an interactive plot with pyplot.
+        from matplotlib import pyplot
+
+        fig = pyplot.figure()
+    else:
+        # We can create a non-interactive figure.
+        from .plotting import make_figure
+
+        fig = make_figure()
 
     if diff is None:
         diff = lhs - rhs
-    pyplot.figure()
+
     if bad is not None:
         # make an rgba image that's red and transparent where not bad
         badImage = numpy.zeros(bad.shape + (4,), dtype=numpy.uint8)
@@ -517,29 +640,29 @@ def plotImageDiff(
     vmin2 = numpy.min(diff)
     vmax2 = numpy.max(diff)
     for n, (image, title) in enumerate([(lhs, "lhs"), (rhs, "rhs"), (diff, "diff")]):
-        pyplot.subplot(2, 3, n + 1)
-        im1 = pyplot.imshow(
+        ax = fig.add_subplot(2, 3, n + 1)
+        im1 = ax.imshow(
             image, cmap=pyplot.cm.gray, interpolation="nearest", origin="lower", vmin=vmin1, vmax=vmax1
         )
         if bad is not None:
-            pyplot.imshow(badImage, alpha=0.2, interpolation="nearest", origin="lower")
-        pyplot.axis("off")
-        pyplot.title(title)
-        pyplot.subplot(2, 3, n + 4)
-        im2 = pyplot.imshow(
+            ax.imshow(badImage, alpha=0.2, interpolation="nearest", origin="lower")
+        ax.axis("off")
+        ax.set_title(title)
+        ax = fig.add_subplot(2, 3, n + 4)
+        im2 = ax.imshow(
             image, cmap=pyplot.cm.gray, interpolation="nearest", origin="lower", vmin=vmin2, vmax=vmax2
         )
         if bad is not None:
-            pyplot.imshow(badImage, alpha=0.2, interpolation="nearest", origin="lower")
-        pyplot.axis("off")
-        pyplot.title(title)
-    pyplot.subplots_adjust(left=0.05, bottom=0.05, top=0.92, right=0.75, wspace=0.05, hspace=0.05)
-    cax1 = pyplot.axes([0.8, 0.55, 0.05, 0.4])
-    pyplot.colorbar(im1, cax=cax1)
-    cax2 = pyplot.axes([0.8, 0.05, 0.05, 0.4])
-    pyplot.colorbar(im2, cax=cax2)
+            ax.imshow(badImage, alpha=0.2, interpolation="nearest", origin="lower")
+        ax.axis("off")
+        ax.set_title(title)
+    fig.subplots_adjust(left=0.05, bottom=0.05, top=0.92, right=0.75, wspace=0.05, hspace=0.05)
+    cax1 = fig.add_subplot([0.8, 0.55, 0.05, 0.4])
+    fig.colorbar(im1, cax=cax1)
+    cax2 = fig.add_subplot([0.8, 0.05, 0.05, 0.4])
+    fig.colorbar(im2, cax=cax2)
     if plotFileName:
-        pyplot.savefig(plotFileName)
+        fig.savefig(plotFileName)
     else:
         pyplot.show()
 
@@ -547,16 +670,16 @@ def plotImageDiff(
 @inTestCase
 def assertFloatsAlmostEqual(
     testCase: unittest.TestCase,
-    lhs: Union[float, numpy.ndarray],
-    rhs: Union[float, numpy.ndarray],
-    rtol: Optional[float] = sys.float_info.epsilon,
-    atol: Optional[float] = sys.float_info.epsilon,
-    relTo: Optional[float] = None,
+    lhs: float | numpy.ndarray,
+    rhs: float | numpy.ndarray,
+    rtol: float | None = sys.float_info.epsilon,
+    atol: float | None = sys.float_info.epsilon,
+    relTo: float | None = None,
     printFailures: bool = True,
     plotOnFailure: bool = False,
-    plotFileName: Optional[str] = None,
+    plotFileName: str | None = None,
     invert: bool = False,
-    msg: Optional[str] = None,
+    msg: str | None = None,
     ignoreNaNs: bool = False,
 ) -> None:
     """Highly-configurable floating point comparisons for scalars and arrays.
@@ -673,19 +796,16 @@ def assertFloatsAlmostEqual(
     if failed:
         if numpy.isscalar(bad):
             if rtol is None:
-                errMsg = ["%s %s %s; diff=%s with atol=%s" % (lhs, cmpStr, rhs, absDiff, atol)]
+                errMsg = [f"{lhs} {cmpStr} {rhs}; diff={absDiff} with atol={atol}"]
             elif atol is None:
-                errMsg = [
-                    "%s %s %s; diff=%s/%s=%s with rtol=%s"
-                    % (lhs, cmpStr, rhs, absDiff, relTo, absDiff / relTo, rtol)
-                ]
+                errMsg = [f"{lhs} {cmpStr} {rhs}; diff={absDiff}/{relTo}={absDiff / relTo} with rtol={rtol}"]
             else:
                 errMsg = [
-                    "%s %s %s; diff=%s/%s=%s with rtol=%s, atol=%s"
-                    % (lhs, cmpStr, rhs, absDiff, relTo, absDiff / relTo, rtol, atol)
+                    f"{lhs} {cmpStr} {rhs}; diff={absDiff}/{relTo}={absDiff / relTo} "
+                    f"with rtol={rtol}, atol={atol}"
                 ]
         else:
-            errMsg = ["%d/%d elements %s with rtol=%s, atol=%s" % (bad.sum(), bad.size, failStr, rtol, atol)]
+            errMsg = [f"{bad.sum()}/{bad.size} elements {failStr} with rtol={rtol}, atol={atol}"]
             if plotOnFailure:
                 if len(lhs.shape) != 2 or len(rhs.shape) != 2:
                     raise ValueError("plotOnFailure is only valid for 2-d arrays")
@@ -705,10 +825,10 @@ def assertFloatsAlmostEqual(
                     rhs = numpy.ones(bad.shape, dtype=float) * rhs
                 if rtol is None:
                     for a, b, diff in zip(lhs[bad], rhs[bad], absDiff[bad]):
-                        errMsg.append("%s %s %s (diff=%s)" % (a, cmpStr, b, diff))
+                        errMsg.append(f"{a} {cmpStr} {b} (diff={diff})")
                 else:
                     for a, b, diff, rel in zip(lhs[bad], rhs[bad], absDiff[bad], relTo[bad]):
-                        errMsg.append("%s %s %s (diff=%s/%s=%s)" % (a, cmpStr, b, diff, rel, diff / rel))
+                        errMsg.append(f"{a} {cmpStr} {b} (diff={diff}/{rel}={diff / rel})")
 
     if msg is not None:
         errMsg.append(msg)
@@ -718,8 +838,8 @@ def assertFloatsAlmostEqual(
 @inTestCase
 def assertFloatsNotEqual(
     testCase: unittest.TestCase,
-    lhs: Union[float, numpy.ndarray],
-    rhs: Union[float, numpy.ndarray],
+    lhs: float | numpy.ndarray,
+    rhs: float | numpy.ndarray,
     **kwds: Any,
 ) -> None:
     """Fail a test if the given floating point values are equal to within the
@@ -738,6 +858,8 @@ def assertFloatsNotEqual(
     rhs : scalar or array-like
         RHS value(s) to compare; may be a scalar or array-like of any
         dimension.
+    **kwds : `~typing.Any`
+        Keyword parameters forwarded to `assertFloatsAlmostEqual`.
 
     Raises
     ------
@@ -750,8 +872,8 @@ def assertFloatsNotEqual(
 @inTestCase
 def assertFloatsEqual(
     testCase: unittest.TestCase,
-    lhs: Union[float, numpy.ndarray],
-    rhs: Union[float, numpy.ndarray],
+    lhs: float | numpy.ndarray,
+    rhs: float | numpy.ndarray,
     **kwargs: Any,
 ) -> None:
     """
@@ -770,6 +892,8 @@ def assertFloatsEqual(
     rhs : scalar or array-like
         RHS value(s) to compare; may be a scalar or array-like of any
         dimension.
+    **kwargs : `~typing.Any`
+        Keyword parameters forwarded to `assertFloatsAlmostEqual`.
 
     Raises
     ------
@@ -779,7 +903,7 @@ def assertFloatsEqual(
     return assertFloatsAlmostEqual(testCase, lhs, rhs, rtol=0, atol=0, **kwargs)
 
 
-def _settingsIterator(settings: Dict[str, Sequence[Any]]) -> Iterator[Dict[str, Any]]:
+def _settingsIterator(settings: dict[str, Sequence[Any]]) -> Iterator[dict[str, Any]]:
     """Return an iterator for the provided test settings
 
     Parameters
@@ -813,7 +937,7 @@ def _settingsIterator(settings: Dict[str, Sequence[Any]]) -> Iterator[Dict[str,
 
 
 def classParameters(**settings: Sequence[Any]) -> Callable:
-    """Class decorator for generating unit tests
+    """Class decorator for generating unit tests.
 
     This decorator generates classes with class variables according to the
     supplied ``settings``.
@@ -829,8 +953,7 @@ def classParameters(**settings: Sequence[Any]) -> Callable:
     ::
 
         @classParameters(foo=[1, 2], bar=[3, 4])
-        class MyTestCase(unittest.TestCase):
-            ...
+        class MyTestCase(unittest.TestCase): ...
 
     will generate two classes, as if you wrote::
 
@@ -839,6 +962,7 @@ def classParameters(**settings: Sequence[Any]) -> Callable:
             bar = 3
             ...
 
+
         class MyTestCase_2_4(unittest.TestCase):
             foo = 2
             bar = 4
@@ -847,7 +971,7 @@ def classParameters(**settings: Sequence[Any]) -> Callable:
     Note that the values are embedded in the class name.
     """
 
-    def decorator(cls: Type) -> None:
+    def decorator(cls: type) -> None:
         module = sys.modules[cls.__module__].__dict__
         for params in _settingsIterator(settings):
             name = f"{cls.__name__}_{'_'.join(str(vv) for vv in params.values())}"
@@ -875,8 +999,7 @@ def methodParameters(**settings: Sequence[Any]) -> Callable:
     .. code-block:: python
 
         @methodParameters(foo=[1, 2], bar=[3, 4])
-        def testSomething(self, foo, bar):
-            ...
+        def testSomething(self, foo, bar): ...
 
     will run:
 
@@ -891,7 +1014,7 @@ def methodParameters(**settings: Sequence[Any]) -> Callable:
         def wrapper(self: unittest.TestCase, *args: Any, **kwargs: Any) -> None:
             for params in _settingsIterator(settings):
                 kwargs.update(params)
-                with self.subTest(**params):
+                with self.subTest(**{k: repr(v) for k, v in params.items()}):
                     func(self, *args, **kwargs)
 
         return wrapper
@@ -900,7 +1023,7 @@ def methodParameters(**settings: Sequence[Any]) -> Callable:
 
 
 def _cartesianProduct(settings: Mapping[str, Sequence[Any]]) -> Mapping[str, Sequence[Any]]:
-    """Return the cartesian product of the settings
+    """Return the cartesian product of the settings.
 
     Parameters
     ----------
@@ -925,7 +1048,7 @@ def _cartesianProduct(settings: Mapping[str, Sequence[Any]]) -> Mapping[str, Seq
 
         {"foo": [1, 1, 2, 2], "bar": ["black", "white", "black", "white"]}
     """
-    product: Dict[str, List[Any]] = {kk: [] for kk in settings}
+    product: dict[str, list[Any]] = {kk: [] for kk in settings}
     for values in itertools.product(*settings.values()):
         for kk, vv in zip(settings.keys(), values):
             product[kk].append(vv)
@@ -933,7 +1056,7 @@ def _cartesianProduct(settings: Mapping[str, Sequence[Any]]) -> Mapping[str, Seq
 
 
 def classParametersProduct(**settings: Sequence[Any]) -> Callable:
-    """Class decorator for generating unit tests
+    """Class decorator for generating unit tests.
 
     This decorator generates classes with class variables according to the
     cartesian product of the supplied ``settings``.
@@ -949,8 +1072,7 @@ def classParametersProduct(**settings: Sequence[Any]) -> Callable:
     .. code-block:: python
 
         @classParametersProduct(foo=[1, 2], bar=[3, 4])
-        class MyTestCase(unittest.TestCase):
-            ...
+        class MyTestCase(unittest.TestCase): ...
 
     will generate four classes, as if you wrote::
 
@@ -961,16 +1083,19 @@ def classParametersProduct(**settings: Sequence[Any]) -> Callable:
             bar = 3
             ...
 
+
         class MyTestCase_1_4(unittest.TestCase):
             foo = 1
             bar = 4
             ...
 
+
         class MyTestCase_2_3(unittest.TestCase):
             foo = 2
             bar = 3
             ...
 
+
         class MyTestCase_2_4(unittest.TestCase):
             foo = 2
             bar = 4
@@ -993,9 +1118,8 @@ def methodParametersProduct(**settings: Sequence[Any]) -> Callable:
     **settings : `dict` (`str`: iterable)
         The parameter combinations to test. Each should be an iterable.
 
-    Example
-    -------
-
+    Examples
+    --------
         @methodParametersProduct(foo=[1, 2], bar=["black", "white"])
         def testSomething(self, foo, bar):
             ...
@@ -1016,6 +1140,11 @@ def temporaryDirectory() -> Iterator[str]:
 
     The difference from `tempfile.TemporaryDirectory` is that this ignores
     errors when deleting a directory, which may happen with some filesystems.
+
+    Yields
+    ------
+    `str`
+        Name of the temporary directory.
     """
     tmpdir = tempfile.mkdtemp()
     yield tmpdir