Merge pull request #4399 from hugovk/PillowTestCase-to-pytest

Convert most PillowTestCase methods to pytest

Author: hugovk

Tests/helper.py

@@ -10,6 +10,7 @@
 import unittest
 from io import BytesIO
 
+import pytest
 from PIL import Image, ImageMath
 
 logger = logging.getLogger(__name__)
@@ -64,148 +65,118 @@ def convert_to_comparable(a, b):
     return new_a, new_b
 
 
-class PillowTestCase(unittest.TestCase):
-    def delete_tempfile(self, path):
-        try:
-            os.remove(path)
-        except OSError:
-            pass  # report?
-
-    def assert_deep_equal(self, a, b, msg=None):
-        try:
-            self.assertEqual(
-                len(a),
-                len(b),
-                msg or "got length {}, expected {}".format(len(a), len(b)),
-            )
-            self.assertTrue(
-                all(x == y for x, y in zip(a, b)),
-                msg or "got {}, expected {}".format(a, b),
-            )
-        except Exception:
-            self.assertEqual(a, b, msg)
-
-    def assert_image(self, im, mode, size, msg=None):
-        if mode is not None:
-            self.assertEqual(
-                im.mode,
-                mode,
-                msg or "got mode {!r}, expected {!r}".format(im.mode, mode),
-            )
-
-        if size is not None:
-            self.assertEqual(
-                im.size,
-                size,
-                msg or "got size {!r}, expected {!r}".format(im.size, size),
-            )
-
-    def assert_image_equal(self, a, b, msg=None):
-        self.assertEqual(
-            a.mode, b.mode, msg or "got mode {!r}, expected {!r}".format(a.mode, b.mode)
-        )
-        self.assertEqual(
-            a.size, b.size, msg or "got size {!r}, expected {!r}".format(a.size, b.size)
+def assert_deep_equal(a, b, msg=None):
+    try:
+        assert len(a) == len(b), msg or "got length {}, expected {}".format(
+            len(a), len(b)
         )
-        if a.tobytes() != b.tobytes():
-            if HAS_UPLOADER:
-                try:
-                    url = test_image_results.upload(a, b)
-                    logger.error("Url for test images: %s" % url)
-                except Exception:
-                    pass
-
-            self.fail(msg or "got different content")
-
-    def assert_image_equal_tofile(self, a, filename, msg=None, mode=None):
-        with Image.open(filename) as img:
-            if mode:
-                img = img.convert(mode)
-            self.assert_image_equal(a, img, msg)
-
-    def assert_image_similar(self, a, b, epsilon, msg=None):
-        self.assertEqual(
-            a.mode, b.mode, msg or "got mode {!r}, expected {!r}".format(a.mode, b.mode)
+    except Exception:
+        assert a == b, msg
+
+
+def assert_image(im, mode, size, msg=None):
+    if mode is not None:
+        assert im.mode == mode, msg or "got mode {!r}, expected {!r}".format(
+            im.mode, mode
         )
-        self.assertEqual(
-            a.size, b.size, msg or "got size {!r}, expected {!r}".format(a.size, b.size)
+
+    if size is not None:
+        assert im.size == size, msg or "got size {!r}, expected {!r}".format(
+            im.size, size
         )
 
-        a, b = convert_to_comparable(a, b)
 
-        diff = 0
-        for ach, bch in zip(a.split(), b.split()):
-            chdiff = ImageMath.eval("abs(a - b)", a=ach, b=bch).convert("L")
-            diff += sum(i * num for i, num in enumerate(chdiff.histogram()))
+def assert_image_equal(a, b, msg=None):
+    assert a.mode == b.mode, msg or "got mode {!r}, expected {!r}".format(
+        a.mode, b.mode
+    )
+    assert a.size == b.size, msg or "got size {!r}, expected {!r}".format(
+        a.size, b.size
+    )
+    if a.tobytes() != b.tobytes():
+        if HAS_UPLOADER:
+            try:
+                url = test_image_results.upload(a, b)
+                logger.error("Url for test images: %s" % url)
+            except Exception:
+                pass
+
+        assert False, msg or "got different content"
+
+
+def assert_image_equal_tofile(a, filename, msg=None, mode=None):
+    with Image.open(filename) as img:
+        if mode:
+            img = img.convert(mode)
+        assert_image_equal(a, img, msg)
 
-        ave_diff = diff / (a.size[0] * a.size[1])
-        try:
-            self.assertGreaterEqual(
-                epsilon,
-                ave_diff,
-                (msg or "")
-                + " average pixel value difference %.4f > epsilon %.4f"
-                % (ave_diff, epsilon),
-            )
-        except Exception as e:
-            if HAS_UPLOADER:
-                try:
-                    url = test_image_results.upload(a, b)
-                    logger.error("Url for test images: %s" % url)
-                except Exception:
-                    pass
-            raise e
-
-    def assert_image_similar_tofile(self, a, filename, epsilon, msg=None, mode=None):
-        with Image.open(filename) as img:
-            if mode:
-                img = img.convert(mode)
-            self.assert_image_similar(a, img, epsilon, msg)
-
-    def assert_warning(self, warn_class, func, *args, **kwargs):
-        import warnings
-
-        with warnings.catch_warnings(record=True) as w:
-            # Cause all warnings to always be triggered.
-            warnings.simplefilter("always")
-
-            # Hopefully trigger a warning.
-            result = func(*args, **kwargs)
-
-            # Verify some things.
-            if warn_class is None:
-                self.assertEqual(
-                    len(w), 0, "Expected no warnings, got %s" % [v.category for v in w]
-                )
-            else:
-                self.assertGreaterEqual(len(w), 1)
-                found = False
-                for v in w:
-                    if issubclass(v.category, warn_class):
-                        found = True
-                        break
-                self.assertTrue(found)
-        return result
 
-    def assert_all_same(self, items, msg=None):
-        self.assertEqual(items.count(items[0]), len(items), msg)
+def assert_image_similar(a, b, epsilon, msg=None):
+    assert a.mode == b.mode, msg or "got mode {!r}, expected {!r}".format(
+        a.mode, b.mode
+    )
+    assert a.size == b.size, msg or "got size {!r}, expected {!r}".format(
+        a.size, b.size
+    )
+
+    a, b = convert_to_comparable(a, b)
+
+    diff = 0
+    for ach, bch in zip(a.split(), b.split()):
+        chdiff = ImageMath.eval("abs(a - b)", a=ach, b=bch).convert("L")
+        diff += sum(i * num for i, num in enumerate(chdiff.histogram()))
+
+    ave_diff = diff / (a.size[0] * a.size[1])
+    try:
+        assert epsilon >= ave_diff, (
+            msg or ""
+        ) + " average pixel value difference %.4f > epsilon %.4f" % (ave_diff, epsilon)
+    except Exception as e:
+        if HAS_UPLOADER:
+            try:
+                url = test_image_results.upload(a, b)
+                logger.error("Url for test images: %s" % url)
+            except Exception:
+                pass
+        raise e
+
+
+def assert_image_similar_tofile(a, filename, epsilon, msg=None, mode=None):
+    with Image.open(filename) as img:
+        if mode:
+            img = img.convert(mode)
+        assert_image_similar(a, img, epsilon, msg)
+
+
+def assert_all_same(items, msg=None):
+    assert items.count(items[0]) == len(items), msg
 
-    def assert_not_all_same(self, items, msg=None):
-        self.assertNotEqual(items.count(items[0]), len(items), msg)
 
-    def assert_tuple_approx_equal(self, actuals, targets, threshold, msg):
-        """Tests if actuals has values within threshold from targets"""
+def assert_not_all_same(items, msg=None):
+    assert items.count(items[0]) != len(items), msg
 
-        value = True
-        for i, target in enumerate(targets):
-            value *= target - threshold <= actuals[i] <= target + threshold
 
-        self.assertTrue(value, msg + ": " + repr(actuals) + " != " + repr(targets))
+def assert_tuple_approx_equal(actuals, targets, threshold, msg):
+    """Tests if actuals has values within threshold from targets"""
+    value = True
+    for i, target in enumerate(targets):
+        value *= target - threshold <= actuals[i] <= target + threshold
 
-    def skipKnownBadTest(self, msg=None):
-        # Skip if PILLOW_RUN_KNOWN_BAD is not true in the environment.
-        if not os.environ.get("PILLOW_RUN_KNOWN_BAD", False):
-            self.skipTest(msg or "Known Bad Test")
+    assert value, msg + ": " + repr(actuals) + " != " + repr(targets)
+
+
+def skip_known_bad_test(msg=None):
+    # Skip if PILLOW_RUN_KNOWN_BAD is not true in the environment.
+    if not os.environ.get("PILLOW_RUN_KNOWN_BAD", False):
+        pytest.skip(msg or "Known bad test")
+
+
+class PillowTestCase(unittest.TestCase):
+    def delete_tempfile(self, path):
+        try:
+            os.remove(path)
+        except OSError:
+            pass  # report?
 
     def tempfile(self, template):
         assert template[:5] in ("temp.", "temp_")

Tests/test_bmp_reference.py

@@ -1,8 +1,9 @@
 import os
 
+import pytest
 from PIL import Image
 
-from .helper import PillowTestCase
+from .helper import PillowTestCase, assert_image_similar
 
 base = os.path.join("Tests", "images", "bmp")
 
@@ -28,7 +29,7 @@ def open(f):
                     pass
 
             # Assert that there is no unclosed file warning
-            self.assert_warning(None, open, f)
+            pytest.warns(None, open, f)
 
     def test_questionable(self):
         """ These shouldn't crash/dos, but it's not well defined that these
@@ -97,7 +98,7 @@ def get_compare(f):
                             # be differently ordered for an equivalent image.
                             im = im.convert("RGBA")
                             compare = im.convert("RGBA")
-                        self.assert_image_similar(im, compare, 5)
+                        assert_image_similar(im, compare, 5)
 
             except Exception as msg:
                 # there are three here that are unsupported:

Tests/test_color_lut.py

@@ -3,7 +3,7 @@
 
 from PIL import Image, ImageFilter
 
-from .helper import PillowTestCase
+from .helper import PillowTestCase, assert_image_equal
 
 try:
     import numpy
@@ -147,7 +147,7 @@ def test_identities(self):
 
         # Fast test with small cubes
         for size in [2, 3, 5, 7, 11, 16, 17]:
-            self.assert_image_equal(
+            assert_image_equal(
                 im,
                 im._new(
                     im.im.color_lut_3d(
@@ -157,7 +157,7 @@ def test_identities(self):
             )
 
         # Not so fast
-        self.assert_image_equal(
+        assert_image_equal(
             im,
             im._new(
                 im.im.color_lut_3d(
@@ -173,7 +173,7 @@ def test_identities_4_channels(self):
         )
 
         # Red channel copied to alpha
-        self.assert_image_equal(
+        assert_image_equal(
             Image.merge("RGBA", (im.split() * 2)[:4]),
             im._new(
                 im.im.color_lut_3d(
@@ -194,7 +194,7 @@ def test_copy_alpha_channel(self):
             ],
         )
 
-        self.assert_image_equal(
+        assert_image_equal(
             im,
             im._new(
                 im.im.color_lut_3d(
@@ -211,7 +211,7 @@ def test_channels_order(self):
 
         # Reverse channels by splitting and using table
         # fmt: off
-        self.assert_image_equal(
+        assert_image_equal(
             Image.merge('RGB', im.split()[::-1]),
             im._new(im.im.color_lut_3d('RGB', Image.LINEAR,
                     3, 2, 2, 2, [
@@ -368,15 +368,15 @@ def test_numpy_formats(self):
 
         lut = ImageFilter.Color3DLUT.generate((7, 9, 11), lambda r, g, b: (r, g, b))
         lut.table = numpy.array(lut.table, dtype=numpy.float16)
-        self.assert_image_equal(im, im.filter(lut))
+        assert_image_equal(im, im.filter(lut))
 
         lut = ImageFilter.Color3DLUT.generate((7, 9, 11), lambda r, g, b: (r, g, b))
         lut.table = numpy.array(lut.table, dtype=numpy.float32)
-        self.assert_image_equal(im, im.filter(lut))
+        assert_image_equal(im, im.filter(lut))
 
         lut = ImageFilter.Color3DLUT.generate((7, 9, 11), lambda r, g, b: (r, g, b))
         lut.table = numpy.array(lut.table, dtype=numpy.float64)
-        self.assert_image_equal(im, im.filter(lut))
+        assert_image_equal(im, im.filter(lut))
 
         lut = ImageFilter.Color3DLUT.generate((7, 9, 11), lambda r, g, b: (r, g, b))
         lut.table = numpy.array(lut.table, dtype=numpy.int32)

Tests/test_core_resources.py

@@ -1,6 +1,7 @@
 import sys
 import unittest
 
+import pytest
 from PIL import Image
 
 from .helper import PillowTestCase, is_pypy
@@ -169,12 +170,12 @@ def test_units(self):
         self.assertEqual(Image.core.get_block_size(), 2 * 1024 * 1024)
 
     def test_warnings(self):
-        self.assert_warning(
+        pytest.warns(
             UserWarning, Image._apply_env_variables, {"PILLOW_ALIGNMENT": "15"}
         )
-        self.assert_warning(
+        pytest.warns(
             UserWarning, Image._apply_env_variables, {"PILLOW_BLOCK_SIZE": "1024"}
         )
-        self.assert_warning(
+        pytest.warns(
             UserWarning, Image._apply_env_variables, {"PILLOW_BLOCKS_MAX": "wat"}
         )