Convert some tests to pytest style

To better follow conventional pytest style, this removes the outer
wrapper class in favor of a function for some tests. These tests were
picked as they are relatively simple and presented no barriers to a
quick port. The assert* methods are replaced with assert statements.
When necessary, a fixture is used to create a temporary directory.

This commit does not convert the entire test suite to this style as some
test classes use methods or other advanced features that are difficult
to automatically convert. The goal is to address these issues in
followup commits.

Refs #4193

Author: jdufresne

Tests/test_000_sanity.py

@@ -1,23 +1,19 @@
 import PIL
 import PIL.Image
 
-from .helper import PillowTestCase
 
+def test_sanity():
+    # Make sure we have the binary extension
+    PIL.Image.core.new("L", (100, 100))
 
-class TestSanity(PillowTestCase):
-    def test_sanity(self):
+    # Create an image and do stuff with it.
+    im = PIL.Image.new("1", (100, 100))
+    assert (im.mode, im.size) == ("1", (100, 100))
+    assert len(im.tobytes()) == 1300
 
-        # Make sure we have the binary extension
-        PIL.Image.core.new("L", (100, 100))
-
-        # Create an image and do stuff with it.
-        im = PIL.Image.new("1", (100, 100))
-        self.assertEqual((im.mode, im.size), ("1", (100, 100)))
-        self.assertEqual(len(im.tobytes()), 1300)
-
-        # Create images in all remaining major modes.
-        PIL.Image.new("L", (100, 100))
-        PIL.Image.new("P", (100, 100))
-        PIL.Image.new("RGB", (100, 100))
-        PIL.Image.new("I", (100, 100))
-        PIL.Image.new("F", (100, 100))
+    # Create images in all remaining major modes.
+    PIL.Image.new("L", (100, 100))
+    PIL.Image.new("P", (100, 100))
+    PIL.Image.new("RGB", (100, 100))
+    PIL.Image.new("I", (100, 100))
+    PIL.Image.new("F", (100, 100))

Tests/test_binary.py

@@ -1,23 +1,22 @@
 from PIL import _binary
 
-from .helper import PillowTestCase
 
+def test_standard():
+    assert _binary.i8(b"*") == 42
+    assert _binary.o8(42) == b"*"
 
-class TestBinary(PillowTestCase):
-    def test_standard(self):
-        self.assertEqual(_binary.i8(b"*"), 42)
-        self.assertEqual(_binary.o8(42), b"*")
 
-    def test_little_endian(self):
-        self.assertEqual(_binary.i16le(b"\xff\xff\x00\x00"), 65535)
-        self.assertEqual(_binary.i32le(b"\xff\xff\x00\x00"), 65535)
+def test_little_endian():
+    assert _binary.i16le(b"\xff\xff\x00\x00") == 65535
+    assert _binary.i32le(b"\xff\xff\x00\x00") == 65535
 
-        self.assertEqual(_binary.o16le(65535), b"\xff\xff")
-        self.assertEqual(_binary.o32le(65535), b"\xff\xff\x00\x00")
+    assert _binary.o16le(65535) == b"\xff\xff"
+    assert _binary.o32le(65535) == b"\xff\xff\x00\x00"
 
-    def test_big_endian(self):
-        self.assertEqual(_binary.i16be(b"\x00\x00\xff\xff"), 0)
-        self.assertEqual(_binary.i32be(b"\x00\x00\xff\xff"), 65535)
 
-        self.assertEqual(_binary.o16be(65535), b"\xff\xff")
-        self.assertEqual(_binary.o32be(65535), b"\x00\x00\xff\xff")
+def test_big_endian():
+    assert _binary.i16be(b"\x00\x00\xff\xff") == 0
+    assert _binary.i32be(b"\x00\x00\xff\xff") == 65535
+
+    assert _binary.o16be(65535) == b"\xff\xff"
+    assert _binary.o32be(65535) == b"\x00\x00\xff\xff"

Tests/test_box_blur.py

@@ -14,12 +14,11 @@
 # fmt: on
 
 
-class TestBoxBlurApi(PillowTestCase):
-    def test_imageops_box_blur(self):
-        i = sample.filter(ImageFilter.BoxBlur(1))
-        self.assertEqual(i.mode, sample.mode)
-        self.assertEqual(i.size, sample.size)
-        self.assertIsInstance(i, Image.Image)
+def test_imageops_box_blur():
+    i = sample.filter(ImageFilter.BoxBlur(1))
+    assert i.mode == sample.mode
+    assert i.size == sample.size
+    assert isinstance(i, Image.Image)
 
 
 class TestBoxBlur(PillowTestCase):

Tests/test_core_resources.py

@@ -6,29 +6,29 @@
 from .helper import PillowTestCase, is_pypy
 
 
-class TestCoreStats(PillowTestCase):
-    def test_get_stats(self):
-        # Create at least one image
-        Image.new("RGB", (10, 10))
-
-        stats = Image.core.get_stats()
-        self.assertIn("new_count", stats)
-        self.assertIn("reused_blocks", stats)
-        self.assertIn("freed_blocks", stats)
-        self.assertIn("allocated_blocks", stats)
-        self.assertIn("reallocated_blocks", stats)
-        self.assertIn("blocks_cached", stats)
-
-    def test_reset_stats(self):
-        Image.core.reset_stats()
-
-        stats = Image.core.get_stats()
-        self.assertEqual(stats["new_count"], 0)
-        self.assertEqual(stats["reused_blocks"], 0)
-        self.assertEqual(stats["freed_blocks"], 0)
-        self.assertEqual(stats["allocated_blocks"], 0)
-        self.assertEqual(stats["reallocated_blocks"], 0)
-        self.assertEqual(stats["blocks_cached"], 0)
+def test_get_stats():
+    # Create at least one image
+    Image.new("RGB", (10, 10))
+
+    stats = Image.core.get_stats()
+    assert "new_count" in stats
+    assert "reused_blocks" in stats
+    assert "freed_blocks" in stats
+    assert "allocated_blocks" in stats
+    assert "reallocated_blocks" in stats
+    assert "blocks_cached" in stats
+
+
+def test_reset_stats():
+    Image.core.reset_stats()
+
+    stats = Image.core.get_stats()
+    assert stats["new_count"] == 0
+    assert stats["reused_blocks"] == 0
+    assert stats["freed_blocks"] == 0
+    assert stats["allocated_blocks"] == 0
+    assert stats["reallocated_blocks"] == 0
+    assert stats["blocks_cached"] == 0
 
 
 class TestCoreMemory(PillowTestCase):

Tests/test_file_bufrstub.py

@@ -1,42 +1,46 @@
+import pytest
 from PIL import BufrStubImagePlugin, Image
 
-from .helper import PillowTestCase, hopper
+from .helper import hopper
 
 TEST_FILE = "Tests/images/gfs.t06z.rassda.tm00.bufr_d"
 
 
-class TestFileBufrStub(PillowTestCase):
-    def test_open(self):
-        # Act
-        with Image.open(TEST_FILE) as im:
+def test_open():
+    # Act
+    with Image.open(TEST_FILE) as im:
 
-            # Assert
-            self.assertEqual(im.format, "BUFR")
+        # Assert
+        assert im.format == "BUFR"
 
-            # Dummy data from the stub
-            self.assertEqual(im.mode, "F")
-            self.assertEqual(im.size, (1, 1))
+        # Dummy data from the stub
+        assert im.mode == "F"
+        assert im.size == (1, 1)
 
-    def test_invalid_file(self):
-        # Arrange
-        invalid_file = "Tests/images/flower.jpg"
 
-        # Act / Assert
-        self.assertRaises(
-            SyntaxError, BufrStubImagePlugin.BufrStubImageFile, invalid_file
-        )
+def test_invalid_file():
+    # Arrange
+    invalid_file = "Tests/images/flower.jpg"
 
-    def test_load(self):
-        # Arrange
-        with Image.open(TEST_FILE) as im:
+    # Act / Assert
+    with pytest.raises(SyntaxError):
+        BufrStubImagePlugin.BufrStubImageFile(invalid_file)
 
-            # Act / Assert: stub cannot load without an implemented handler
-            self.assertRaises(IOError, im.load)
 
-    def test_save(self):
-        # Arrange
-        im = hopper()
-        tmpfile = self.tempfile("temp.bufr")
+def test_load():
+    # Arrange
+    with Image.open(TEST_FILE) as im:
 
-        # Act / Assert: stub cannot save without an implemented handler
-        self.assertRaises(IOError, im.save, tmpfile)
+        # Act / Assert: stub cannot load without an implemented handler
+        with pytest.raises(IOError):
+            im.load()
+
+
+def test_save(tmp_path):
+    # Arrange
+    im = hopper()
+    tmpfile = str(tmp_path / "temp.bufr")
+
+    # Act / Assert: stub cannot save without an implemented handler
+    with pytest.raises(IOError):
+        im.save(tmpfile)