diff --git a/Tests/oss-fuzz/test_fuzzers.py b/Tests/oss-fuzz/test_fuzzers.py
index 58d0213e85d..90eb8713a8b 100644
--- a/Tests/oss-fuzz/test_fuzzers.py
+++ b/Tests/oss-fuzz/test_fuzzers.py
@@ -12,8 +12,9 @@
 
 if sys.platform.startswith("win32"):
     pytest.skip("Fuzzer is linux only", allow_module_level=True)
-if features.check("libjpeg_turbo"):
-    version = packaging.version.parse(features.version("libjpeg_turbo"))
+libjpeg_turbo_version = features.version("libjpeg_turbo")
+if libjpeg_turbo_version is not None:
+    version = packaging.version.parse(libjpeg_turbo_version)
     if version.major == 2 and version.minor == 0:
         pytestmark = pytest.mark.valgrind_known_error(
             reason="Known failing with libjpeg_turbo 2.0"
diff --git a/Tests/test_features.py b/Tests/test_features.py
index 2d402ca9114..59fb4980923 100644
--- a/Tests/test_features.py
+++ b/Tests/test_features.py
@@ -30,7 +30,7 @@ def test_version() -> None:
     # Check the correctness of the convenience function
     # and the format of version numbers
 
-    def test(name: str, function: Callable[[str], bool]) -> None:
+    def test(name: str, function: Callable[[str], str | None]) -> None:
         version = features.version(name)
         if not features.check(name):
             assert version is None
@@ -67,12 +67,16 @@ def test_webp_anim() -> None:
 
 @skip_unless_feature("libjpeg_turbo")
 def test_libjpeg_turbo_version() -> None:
-    assert re.search(r"\d+\.\d+\.\d+$", features.version("libjpeg_turbo"))
+    version = features.version("libjpeg_turbo")
+    assert version is not None
+    assert re.search(r"\d+\.\d+\.\d+$", version)
 
 
 @skip_unless_feature("libimagequant")
 def test_libimagequant_version() -> None:
-    assert re.search(r"\d+\.\d+\.\d+$", features.version("libimagequant"))
+    version = features.version("libimagequant")
+    assert version is not None
+    assert re.search(r"\d+\.\d+\.\d+$", version)
 
 
 @pytest.mark.parametrize("feature", features.modules)
diff --git a/Tests/test_file_jpeg.py b/Tests/test_file_jpeg.py
index 5d2157651df..f24faecaab2 100644
--- a/Tests/test_file_jpeg.py
+++ b/Tests/test_file_jpeg.py
@@ -70,7 +70,9 @@ def gen_random_image(self, size: tuple[int, int], mode: str = "RGB") -> Image.Im
 
     def test_sanity(self) -> None:
         # internal version number
-        assert re.search(r"\d+\.\d+$", features.version_codec("jpg"))
+        version = features.version_codec("jpg")
+        assert version is not None
+        assert re.search(r"\d+\.\d+$", version)
 
         with Image.open(TEST_FILE) as im:
             im.load()
diff --git a/Tests/test_file_jpeg2k.py b/Tests/test_file_jpeg2k.py
index a7cae563adb..5a208739f70 100644
--- a/Tests/test_file_jpeg2k.py
+++ b/Tests/test_file_jpeg2k.py
@@ -48,7 +48,9 @@ def roundtrip(im: Image.Image, **options: Any) -> Image.Image:
 
 def test_sanity() -> None:
     # Internal version number
-    assert re.search(r"\d+\.\d+\.\d+$", features.version_codec("jpg_2000"))
+    version = features.version_codec("jpg_2000")
+    assert version is not None
+    assert re.search(r"\d+\.\d+\.\d+$", version)
 
     with Image.open("Tests/images/test-card-lossless.jp2") as im:
         px = im.load()
diff --git a/Tests/test_file_libtiff.py b/Tests/test_file_libtiff.py
index 11883ad24aa..6c13999a50a 100644
--- a/Tests/test_file_libtiff.py
+++ b/Tests/test_file_libtiff.py
@@ -52,7 +52,9 @@ def _assert_noerr(self, tmp_path: Path, im: TiffImagePlugin.TiffImageFile) -> No
 
 class TestFileLibTiff(LibTiffTestCase):
     def test_version(self) -> None:
-        assert re.search(r"\d+\.\d+\.\d+$", features.version_codec("libtiff"))
+        version = features.version_codec("libtiff")
+        assert version is not None
+        assert re.search(r"\d+\.\d+\.\d+$", version)
 
     def test_g4_tiff(self, tmp_path: Path) -> None:
         """Test the ordinary file path load path"""
diff --git a/Tests/test_file_png.py b/Tests/test_file_png.py
index 19462dcb5a4..c7c9f6fab0b 100644
--- a/Tests/test_file_png.py
+++ b/Tests/test_file_png.py
@@ -85,9 +85,9 @@ def get_chunks(self, filename: str) -> list[bytes]:
 
     def test_sanity(self, tmp_path: Path) -> None:
         # internal version number
-        assert re.search(
-            r"\d+(\.\d+){1,3}(\.zlib\-ng)?$", features.version_codec("zlib")
-        )
+        version = features.version_codec("zlib")
+        assert version is not None
+        assert re.search(r"\d+(\.\d+){1,3}(\.zlib\-ng)?$", version)
 
         test_file = str(tmp_path / "temp.png")
 
diff --git a/Tests/test_file_webp.py b/Tests/test_file_webp.py
index 249846da481..e2de84c71a1 100644
--- a/Tests/test_file_webp.py
+++ b/Tests/test_file_webp.py
@@ -49,7 +49,9 @@ def setup_method(self) -> None:
     def test_version(self) -> None:
         _webp.WebPDecoderVersion()
         _webp.WebPDecoderBuggyAlpha()
-        assert re.search(r"\d+\.\d+\.\d+$", features.version_module("webp"))
+        version = features.version_module("webp")
+        assert version is not None
+        assert re.search(r"\d+\.\d+\.\d+$", version)
 
     def test_read_rgb(self) -> None:
         """
diff --git a/Tests/test_image_quantize.py b/Tests/test_image_quantize.py
index e1aa6252b7a..2daaf5c3cbb 100644
--- a/Tests/test_image_quantize.py
+++ b/Tests/test_image_quantize.py
@@ -24,8 +24,9 @@ def test_sanity() -> None:
 def test_libimagequant_quantize() -> None:
     image = hopper()
     if is_ppc64le():
-        libimagequant = parse_version(features.version_feature("libimagequant"))
-        if libimagequant < parse_version("4"):
+        version = features.version_feature("libimagequant")
+        assert version is not None
+        if parse_version(version) < parse_version("4"):
             pytest.skip("Fails with libimagequant earlier than 4.0.0 on ppc64le")
     converted = image.quantize(100, Image.Quantize.LIBIMAGEQUANT)
     assert converted.mode == "P"
diff --git a/Tests/test_image_reduce.py b/Tests/test_image_reduce.py
index fcf671daace..f6609a1a054 100644
--- a/Tests/test_image_reduce.py
+++ b/Tests/test_image_reduce.py
@@ -102,7 +102,7 @@ def test_unsupported_modes(mode: str) -> None:
 def get_image(mode: str) -> Image.Image:
     mode_info = ImageMode.getmode(mode)
     if mode_info.basetype == "L":
-        bands = [gradients_image]
+        bands: list[Image.Image] = [gradients_image]
         for _ in mode_info.bands[1:]:
             # rotate previous image
             band = bands[-1].transpose(Image.Transpose.ROTATE_90)
diff --git a/Tests/test_imageops_usm.py b/Tests/test_imageops_usm.py
index c15907a554a..104c620de01 100644
--- a/Tests/test_imageops_usm.py
+++ b/Tests/test_imageops_usm.py
@@ -4,11 +4,11 @@
 
 import pytest
 
-from PIL import Image, ImageFilter
+from PIL import Image, ImageFile, ImageFilter
 
 
 @pytest.fixture
-def test_images() -> Generator[dict[str, Image.Image], None, None]:
+def test_images() -> Generator[dict[str, ImageFile.ImageFile], None, None]:
     ims = {
         "im": Image.open("Tests/images/hopper.ppm"),
         "snakes": Image.open("Tests/images/color_snakes.png"),
@@ -20,7 +20,7 @@ def test_images() -> Generator[dict[str, Image.Image], None, None]:
             im.close()
 
 
-def test_filter_api(test_images: dict[str, Image.Image]) -> None:
+def test_filter_api(test_images: dict[str, ImageFile.ImageFile]) -> None:
     im = test_images["im"]
 
     test_filter = ImageFilter.GaussianBlur(2.0)
@@ -34,7 +34,7 @@ def test_filter_api(test_images: dict[str, Image.Image]) -> None:
     assert i.size == (128, 128)
 
 
-def test_usm_formats(test_images: dict[str, Image.Image]) -> None:
+def test_usm_formats(test_images: dict[str, ImageFile.ImageFile]) -> None:
     im = test_images["im"]
 
     usm = ImageFilter.UnsharpMask
@@ -52,7 +52,7 @@ def test_usm_formats(test_images: dict[str, Image.Image]) -> None:
         im.convert("YCbCr").filter(usm)
 
 
-def test_blur_formats(test_images: dict[str, Image.Image]) -> None:
+def test_blur_formats(test_images: dict[str, ImageFile.ImageFile]) -> None:
     im = test_images["im"]
 
     blur = ImageFilter.GaussianBlur
@@ -70,7 +70,7 @@ def test_blur_formats(test_images: dict[str, Image.Image]) -> None:
         im.convert("YCbCr").filter(blur)
 
 
-def test_usm_accuracy(test_images: dict[str, Image.Image]) -> None:
+def test_usm_accuracy(test_images: dict[str, ImageFile.ImageFile]) -> None:
     snakes = test_images["snakes"]
 
     src = snakes.convert("RGB")
@@ -79,7 +79,7 @@ def test_usm_accuracy(test_images: dict[str, Image.Image]) -> None:
     assert i.tobytes() == src.tobytes()
 
 
-def test_blur_accuracy(test_images: dict[str, Image.Image]) -> None:
+def test_blur_accuracy(test_images: dict[str, ImageFile.ImageFile]) -> None:
     snakes = test_images["snakes"]
 
     i = snakes.filter(ImageFilter.GaussianBlur(0.4))
