Merge pull request #4232 from radarhere/contextmanagers

Use context managers in tests

Tests/check_fli_overflow.py

@@ -11,8 +11,8 @@ class TestFliOverflow(PillowTestCase):
     def test_fli_overflow(self):
 
         # this should not crash with a malloc error or access violation
-        im = Image.open(TEST_FILE)
-        im.load()
+        with Image.open(TEST_FILE) as im:
+            im.load()
 
 
 if __name__ == "__main__":

Tests/check_libtiff_segfault.py

@@ -14,8 +14,8 @@ def test_segfault(self):
             """
 
         with self.assertRaises(IOError):
-            im = Image.open(TEST_FILE)
-            im.load()
+            with Image.open(TEST_FILE) as im:
+                im.load()
 
 
 if __name__ == "__main__":

Tests/test_file_blp.py

@@ -15,6 +15,6 @@ def test_load_blp2_dxt1(self):
                 self.assert_image_equal(im, target)
 
     def test_load_blp2_dxt1a(self):
-        im = Image.open("Tests/images/blp/blp2_dxt1a.blp")
-        target = Image.open("Tests/images/blp/blp2_dxt1a.png")
-        self.assert_image_equal(im, target)
+        with Image.open("Tests/images/blp/blp2_dxt1a.blp") as im:
+            with Image.open("Tests/images/blp/blp2_dxt1a.png") as target:
+                self.assert_image_equal(im, target)

Tests/test_file_bmp.py

@@ -11,12 +11,12 @@ def roundtrip(self, im):
 
         im.save(outfile, "BMP")
 
-        reloaded = Image.open(outfile)
-        reloaded.load()
-        self.assertEqual(im.mode, reloaded.mode)
-        self.assertEqual(im.size, reloaded.size)
-        self.assertEqual(reloaded.format, "BMP")
-        self.assertEqual(reloaded.get_format_mimetype(), "image/bmp")
+        with Image.open(outfile) as reloaded:
+            reloaded.load()
+            self.assertEqual(im.mode, reloaded.mode)
+            self.assertEqual(im.size, reloaded.size)
+            self.assertEqual(reloaded.format, "BMP")
+            self.assertEqual(reloaded.get_format_mimetype(), "image/bmp")
 
     def test_sanity(self):
         self.roundtrip(hopper())
@@ -36,11 +36,10 @@ def test_save_to_bytes(self):
         im.save(output, "BMP")
 
         output.seek(0)
-        reloaded = Image.open(output)
-
-        self.assertEqual(im.mode, reloaded.mode)
-        self.assertEqual(im.size, reloaded.size)
-        self.assertEqual(reloaded.format, "BMP")
+        with Image.open(output) as reloaded:
+            self.assertEqual(im.mode, reloaded.mode)
+            self.assertEqual(im.size, reloaded.size)
+            self.assertEqual(reloaded.format, "BMP")
 
     def test_dpi(self):
         dpi = (72, 72)
@@ -57,17 +56,17 @@ def test_save_bmp_with_dpi(self):
         # Test for #1301
         # Arrange
         outfile = self.tempfile("temp.jpg")
-        im = Image.open("Tests/images/hopper.bmp")
+        with Image.open("Tests/images/hopper.bmp") as im:
 
-        # Act
-        im.save(outfile, "JPEG", dpi=im.info["dpi"])
+            # Act
+            im.save(outfile, "JPEG", dpi=im.info["dpi"])
 
-        # Assert
-        reloaded = Image.open(outfile)
-        reloaded.load()
-        self.assertEqual(im.info["dpi"], reloaded.info["dpi"])
-        self.assertEqual(im.size, reloaded.size)
-        self.assertEqual(reloaded.format, "JPEG")
+            # Assert
+            with Image.open(outfile) as reloaded:
+                reloaded.load()
+                self.assertEqual(im.info["dpi"], reloaded.info["dpi"])
+                self.assertEqual(im.size, reloaded.size)
+                self.assertEqual(reloaded.format, "JPEG")
 
     def test_load_dpi_rounding(self):
         # Round up
@@ -80,44 +79,43 @@ def test_load_dpi_rounding(self):
 
     def test_save_dpi_rounding(self):
         outfile = self.tempfile("temp.bmp")
-        im = Image.open("Tests/images/hopper.bmp")
-
-        im.save(outfile, dpi=(72.2, 72.2))
-        with Image.open(outfile) as reloaded:
-            self.assertEqual(reloaded.info["dpi"], (72, 72))
+        with Image.open("Tests/images/hopper.bmp") as im:
+            im.save(outfile, dpi=(72.2, 72.2))
+            with Image.open(outfile) as reloaded:
+                self.assertEqual(reloaded.info["dpi"], (72, 72))
 
             im.save(outfile, dpi=(72.8, 72.8))
         with Image.open(outfile) as reloaded:
             self.assertEqual(reloaded.info["dpi"], (73, 73))
 
     def test_load_dib(self):
         # test for #1293, Imagegrab returning Unsupported Bitfields Format
-        im = Image.open("Tests/images/clipboard.dib")
-        self.assertEqual(im.format, "DIB")
-        self.assertEqual(im.get_format_mimetype(), "image/bmp")
+        with Image.open("Tests/images/clipboard.dib") as im:
+            self.assertEqual(im.format, "DIB")
+            self.assertEqual(im.get_format_mimetype(), "image/bmp")
 
-        target = Image.open("Tests/images/clipboard_target.png")
-        self.assert_image_equal(im, target)
+            with Image.open("Tests/images/clipboard_target.png") as target:
+                self.assert_image_equal(im, target)
 
     def test_save_dib(self):
         outfile = self.tempfile("temp.dib")
 
-        im = Image.open("Tests/images/clipboard.dib")
-        im.save(outfile)
+        with Image.open("Tests/images/clipboard.dib") as im:
+            im.save(outfile)
 
-        reloaded = Image.open(outfile)
-        self.assertEqual(reloaded.format, "DIB")
-        self.assertEqual(reloaded.get_format_mimetype(), "image/bmp")
-        self.assert_image_equal(im, reloaded)
+            with Image.open(outfile) as reloaded:
+                self.assertEqual(reloaded.format, "DIB")
+                self.assertEqual(reloaded.get_format_mimetype(), "image/bmp")
+                self.assert_image_equal(im, reloaded)
 
     def test_rgba_bitfields(self):
         # This test image has been manually hexedited
         # to change the bitfield compression in the header from XBGR to RGBA
-        im = Image.open("Tests/images/rgb32bf-rgba.bmp")
+        with Image.open("Tests/images/rgb32bf-rgba.bmp") as im:
 
-        # So before the comparing the image, swap the channels
-        b, g, r = im.split()[1:]
-        im = Image.merge("RGB", (r, g, b))
+            # So before the comparing the image, swap the channels
+            b, g, r = im.split()[1:]
+            im = Image.merge("RGB", (r, g, b))
 
-        target = Image.open("Tests/images/bmp/q/rgb32bf-xbgr.bmp")
-        self.assert_image_equal(im, target)
+        with Image.open("Tests/images/bmp/q/rgb32bf-xbgr.bmp") as target:
+            self.assert_image_equal(im, target)

Tests/test_file_cur.py

@@ -7,14 +7,13 @@
 
 class TestFileCur(PillowTestCase):
     def test_sanity(self):
-        im = Image.open(TEST_FILE)
-
-        self.assertEqual(im.size, (32, 32))
-        self.assertIsInstance(im, CurImagePlugin.CurImageFile)
-        # Check some pixel colors to ensure image is loaded properly
-        self.assertEqual(im.getpixel((10, 1)), (0, 0, 0, 0))
-        self.assertEqual(im.getpixel((11, 1)), (253, 254, 254, 1))
-        self.assertEqual(im.getpixel((16, 16)), (84, 87, 86, 255))
+        with Image.open(TEST_FILE) as im:
+            self.assertEqual(im.size, (32, 32))
+            self.assertIsInstance(im, CurImagePlugin.CurImageFile)
+            # Check some pixel colors to ensure image is loaded properly
+            self.assertEqual(im.getpixel((10, 1)), (0, 0, 0, 0))
+            self.assertEqual(im.getpixel((11, 1)), (253, 254, 254, 1))
+            self.assertEqual(im.getpixel((16, 16)), (84, 87, 86, 255))
 
     def test_invalid_file(self):
         invalid_file = "Tests/images/flower.jpg"

Tests/test_file_dds.py

@@ -17,73 +17,71 @@ class TestFileDds(PillowTestCase):
 
     def test_sanity_dxt1(self):
         """Check DXT1 images can be opened"""
-        target = Image.open(TEST_FILE_DXT1.replace(".dds", ".png"))
+        with Image.open(TEST_FILE_DXT1.replace(".dds", ".png")) as target:
+            target = target.convert("RGBA")
+        with Image.open(TEST_FILE_DXT1) as im:
+            im.load()
 
-        im = Image.open(TEST_FILE_DXT1)
-        im.load()
+            self.assertEqual(im.format, "DDS")
+            self.assertEqual(im.mode, "RGBA")
+            self.assertEqual(im.size, (256, 256))
 
-        self.assertEqual(im.format, "DDS")
-        self.assertEqual(im.mode, "RGBA")
-        self.assertEqual(im.size, (256, 256))
-
-        self.assert_image_equal(target.convert("RGBA"), im)
+            self.assert_image_equal(im, target)
 
     def test_sanity_dxt5(self):
         """Check DXT5 images can be opened"""
 
-        target = Image.open(TEST_FILE_DXT5.replace(".dds", ".png"))
-
-        im = Image.open(TEST_FILE_DXT5)
-        im.load()
+        with Image.open(TEST_FILE_DXT5) as im:
+            im.load()
 
         self.assertEqual(im.format, "DDS")
         self.assertEqual(im.mode, "RGBA")
         self.assertEqual(im.size, (256, 256))
 
-        self.assert_image_equal(target, im)
+        with Image.open(TEST_FILE_DXT5.replace(".dds", ".png")) as target:
+            self.assert_image_equal(target, im)
 
     def test_sanity_dxt3(self):
         """Check DXT3 images can be opened"""
 
-        target = Image.open(TEST_FILE_DXT3.replace(".dds", ".png"))
+        with Image.open(TEST_FILE_DXT3.replace(".dds", ".png")) as target:
+            with Image.open(TEST_FILE_DXT3) as im:
+                im.load()
 
-        im = Image.open(TEST_FILE_DXT3)
-        im.load()
+                self.assertEqual(im.format, "DDS")
+                self.assertEqual(im.mode, "RGBA")
+                self.assertEqual(im.size, (256, 256))
 
-        self.assertEqual(im.format, "DDS")
-        self.assertEqual(im.mode, "RGBA")
-        self.assertEqual(im.size, (256, 256))
-
-        self.assert_image_equal(target, im)
+                self.assert_image_equal(target, im)
 
     def test_dx10_bc7(self):
         """Check DX10 images can be opened"""
 
-        target = Image.open(TEST_FILE_DX10_BC7.replace(".dds", ".png"))
+        with Image.open(TEST_FILE_DX10_BC7) as im:
+            im.load()
 
-        im = Image.open(TEST_FILE_DX10_BC7)
-        im.load()
+            self.assertEqual(im.format, "DDS")
+            self.assertEqual(im.mode, "RGBA")
+            self.assertEqual(im.size, (256, 256))
 
-        self.assertEqual(im.format, "DDS")
-        self.assertEqual(im.mode, "RGBA")
-        self.assertEqual(im.size, (256, 256))
-
-        self.assert_image_equal(target, im)
+            with Image.open(TEST_FILE_DX10_BC7.replace(".dds", ".png")) as target:
+                self.assert_image_equal(target, im)
 
     def test_dx10_bc7_unorm_srgb(self):
         """Check DX10 unsigned normalized integer images can be opened"""
 
-        target = Image.open(TEST_FILE_DX10_BC7_UNORM_SRGB.replace(".dds", ".png"))
-
-        im = Image.open(TEST_FILE_DX10_BC7_UNORM_SRGB)
-        im.load()
+        with Image.open(TEST_FILE_DX10_BC7_UNORM_SRGB) as im:
+            im.load()
 
-        self.assertEqual(im.format, "DDS")
-        self.assertEqual(im.mode, "RGBA")
-        self.assertEqual(im.size, (16, 16))
-        self.assertEqual(im.info["gamma"], 1 / 2.2)
+            self.assertEqual(im.format, "DDS")
+            self.assertEqual(im.mode, "RGBA")
+            self.assertEqual(im.size, (16, 16))
+            self.assertEqual(im.info["gamma"], 1 / 2.2)
 
-        self.assert_image_equal(target, im)
+            with Image.open(
+                TEST_FILE_DX10_BC7_UNORM_SRGB.replace(".dds", ".png")
+            ) as target:
+                self.assert_image_equal(target, im)
 
     def test_unimplemented_dxgi_format(self):
         self.assertRaises(
@@ -95,16 +93,17 @@ def test_unimplemented_dxgi_format(self):
     def test_uncompressed_rgb(self):
         """Check uncompressed RGB images can be opened"""
 
-        target = Image.open(TEST_FILE_UNCOMPRESSED_RGB.replace(".dds", ".png"))
-
-        im = Image.open(TEST_FILE_UNCOMPRESSED_RGB)
-        im.load()
+        with Image.open(TEST_FILE_UNCOMPRESSED_RGB) as im:
+            im.load()
 
-        self.assertEqual(im.format, "DDS")
-        self.assertEqual(im.mode, "RGBA")
-        self.assertEqual(im.size, (800, 600))
+            self.assertEqual(im.format, "DDS")
+            self.assertEqual(im.mode, "RGBA")
+            self.assertEqual(im.size, (800, 600))
 
-        self.assert_image_equal(target, im)
+            with Image.open(
+                TEST_FILE_UNCOMPRESSED_RGB.replace(".dds", ".png")
+            ) as target:
+                self.assert_image_equal(target, im)
 
     def test__validate_true(self):
         """Check valid prefix"""
@@ -145,8 +144,8 @@ def test_short_file(self):
             img_file = f.read()
 
         def short_file():
-            im = Image.open(BytesIO(img_file[:-100]))
-            im.load()
+            with Image.open(BytesIO(img_file[:-100])) as im:
+                im.load()
 
         self.assertRaises(IOError, short_file)
 

Tests/test_file_eps.py

@@ -68,8 +68,8 @@ def test_cmyk(self):
             self.assertEqual(cmyk_image.mode, "RGB")
 
             if "jpeg_decoder" in dir(Image.core):
-                target = Image.open("Tests/images/pil_sample_rgb.jpg")
-                self.assert_image_similar(cmyk_image, target, 10)
+                with Image.open("Tests/images/pil_sample_rgb.jpg") as target:
+                    self.assert_image_similar(cmyk_image, target, 10)
 
     @unittest.skipUnless(HAS_GHOSTSCRIPT, "Ghostscript not available")
     def test_showpage(self):
@@ -100,12 +100,13 @@ def test_bytesio_object(self):
         with open(file1, "rb") as f:
             img_bytes = io.BytesIO(f.read())
 
-        img = Image.open(img_bytes)
-        img.load()
+        with Image.open(img_bytes) as img:
+            img.load()
 
-        image1_scale1_compare = Image.open(file1_compare).convert("RGB")
-        image1_scale1_compare.load()
-        self.assert_image_similar(img, image1_scale1_compare, 5)
+            with Image.open(file1_compare) as image1_scale1_compare:
+                image1_scale1_compare = image1_scale1_compare.convert("RGB")
+            image1_scale1_compare.load()
+            self.assert_image_similar(img, image1_scale1_compare, 5)
 
     def test_image_mode_not_supported(self):
         im = hopper("RGBA")
@@ -122,14 +123,16 @@ def test_render_scale1(self):
         # Zero bounding box
         with Image.open(file1) as image1_scale1:
             image1_scale1.load()
-            image1_scale1_compare = Image.open(file1_compare).convert("RGB")
+            with Image.open(file1_compare) as image1_scale1_compare:
+                image1_scale1_compare = image1_scale1_compare.convert("RGB")
             image1_scale1_compare.load()
             self.assert_image_similar(image1_scale1, image1_scale1_compare, 5)
 
         # Non-Zero bounding box
         with Image.open(file2) as image2_scale1:
             image2_scale1.load()
-            image2_scale1_compare = Image.open(file2_compare).convert("RGB")
+            with Image.open(file2_compare) as image2_scale1_compare:
+                image2_scale1_compare = image2_scale1_compare.convert("RGB")
             image2_scale1_compare.load()
             self.assert_image_similar(image2_scale1, image2_scale1_compare, 10)
 
@@ -143,14 +146,16 @@ def test_render_scale2(self):
         # Zero bounding box
         with Image.open(file1) as image1_scale2:
             image1_scale2.load(scale=2)
-            image1_scale2_compare = Image.open(file1_compare_scale2).convert("RGB")
+            with Image.open(file1_compare_scale2) as image1_scale2_compare:
+                image1_scale2_compare = image1_scale2_compare.convert("RGB")
             image1_scale2_compare.load()
             self.assert_image_similar(image1_scale2, image1_scale2_compare, 5)
 
         # Non-Zero bounding box
         with Image.open(file2) as image2_scale2:
             image2_scale2.load(scale=2)
-            image2_scale2_compare = Image.open(file2_compare_scale2).convert("RGB")
+            with Image.open(file2_compare_scale2) as image2_scale2_compare:
+                image2_scale2_compare = image2_scale2_compare.convert("RGB")
             image2_scale2_compare.load()
             self.assert_image_similar(image2_scale2, image2_scale2_compare, 10)