From 8482919a3720cb6185975de75fd712a9a5556653 Mon Sep 17 00:00:00 2001 From: Andrew Murray Date: Sun, 23 Feb 2020 00:06:21 +1100 Subject: [PATCH] Converted most assert statements to pytest --- Tests/check_libtiff_segfault.py | 3 +- Tests/check_png_dos.py | 14 +- Tests/helper.py | 2 +- Tests/test_color_lut.py | 154 ++++++++++---------- Tests/test_core_resources.py | 76 +++++----- Tests/test_file_eps.py | 59 ++++---- Tests/test_file_gif.py | 122 ++++++++-------- Tests/test_file_icns.py | 37 ++--- Tests/test_file_ico.py | 35 +++-- Tests/test_file_jpeg.py | 214 +++++++++++++-------------- Tests/test_file_jpeg2k.py | 38 ++--- Tests/test_file_libtiff.py | 238 +++++++++++++++--------------- Tests/test_file_libtiff_small.py | 6 +- Tests/test_file_msp.py | 18 ++- Tests/test_file_palm.py | 12 +- Tests/test_file_pcx.py | 21 +-- Tests/test_file_pdf.py | 144 +++++++++--------- Tests/test_file_png.py | 226 +++++++++++++++-------------- Tests/test_file_ppm.py | 24 +-- Tests/test_file_sgi.py | 13 +- Tests/test_file_spider.py | 44 +++--- Tests/test_file_tga.py | 86 ++++++----- Tests/test_file_tiff.py | 205 +++++++++++++------------- Tests/test_file_tiff_metadata.py | 154 +++++++++----------- Tests/test_file_webp.py | 38 ++--- Tests/test_file_wmf.py | 14 +- Tests/test_font_pcf.py | 16 +- Tests/test_image.py | 228 +++++++++++++++-------------- Tests/test_image_access.py | 70 ++++----- Tests/test_image_convert.py | 52 +++---- Tests/test_image_paste.py | 6 +- Tests/test_image_reduce.py | 70 ++++----- Tests/test_image_resample.py | 48 +++--- Tests/test_image_resize.py | 66 ++++----- Tests/test_image_split.py | 48 +++--- Tests/test_image_transform.py | 22 ++- Tests/test_imagefile.py | 107 ++++++++------ Tests/test_imagefont.py | 241 +++++++++++++++---------------- Tests/test_imagefontctl.py | 2 +- Tests/test_imagegrab.py | 6 +- Tests/test_imagemorph.py | 101 ++++++------- Tests/test_imageops_usm.py | 53 ++++--- Tests/test_imagepalette.py | 65 +++++---- Tests/test_imagepath.py | 59 ++++---- Tests/test_imageqt.py | 8 +- Tests/test_imagesequence.py | 28 ++-- Tests/test_imagewin.py | 16 +- Tests/test_lib_pack.py | 14 +- Tests/test_mode_i16.py | 28 ++-- Tests/test_pickle.py | 6 +- Tests/test_qt_image_toqimage.py | 4 +- Tests/test_qt_image_toqpixmap.py | 4 +- Tests/test_tiff_ifdrational.py | 20 ++- 53 files changed, 1716 insertions(+), 1669 deletions(-) diff --git a/Tests/check_libtiff_segfault.py b/Tests/check_libtiff_segfault.py index b272c601c..711168f65 100644 --- a/Tests/check_libtiff_segfault.py +++ b/Tests/check_libtiff_segfault.py @@ -1,5 +1,6 @@ import unittest +import pytest from PIL import Image from .helper import PillowTestCase @@ -13,7 +14,7 @@ class TestLibtiffSegfault(PillowTestCase): libtiff >= 4.0.0 """ - with self.assertRaises(IOError): + with pytest.raises(IOError): with Image.open(TEST_FILE) as im: im.load() diff --git a/Tests/check_png_dos.py b/Tests/check_png_dos.py index f133b2695..b981d36bf 100644 --- a/Tests/check_png_dos.py +++ b/Tests/check_png_dos.py @@ -20,10 +20,10 @@ class TestPngDos(PillowTestCase): ImageFile.LOAD_TRUNCATED_IMAGES = False for s in im.text.values(): - self.assertLess(len(s), 1024 * 1024, "Text chunk larger than 1M") + assert len(s) < 1024 * 1024, "Text chunk larger than 1M" for s in im.info.values(): - self.assertLess(len(s), 1024 * 1024, "Text chunk larger than 1M") + assert len(s) < 1024 * 1024, "Text chunk larger than 1M" def test_dos_text(self): @@ -31,11 +31,11 @@ class TestPngDos(PillowTestCase): im = Image.open(TEST_FILE) im.load() except ValueError as msg: - self.assertTrue(msg, "Decompressed Data Too Large") + assert msg, "Decompressed Data Too Large" return for s in im.text.values(): - self.assertLess(len(s), 1024 * 1024, "Text chunk larger than 1M") + assert len(s) < 1024 * 1024, "Text chunk larger than 1M" def test_dos_total_memory(self): im = Image.new("L", (1, 1)) @@ -54,15 +54,13 @@ class TestPngDos(PillowTestCase): try: im2 = Image.open(b) except ValueError as msg: - self.assertIn("Too much memory", msg) + assert "Too much memory" in msg return total_len = 0 for txt in im2.text.values(): total_len += len(txt) - self.assertLess( - total_len, 64 * 1024 * 1024, "Total text chunks greater than 64M" - ) + assert total_len < 64 * 1024 * 1024, "Total text chunks greater than 64M" if __name__ == "__main__": diff --git a/Tests/helper.py b/Tests/helper.py index 621830333..d20b64b5f 100644 --- a/Tests/helper.py +++ b/Tests/helper.py @@ -240,7 +240,7 @@ class PillowLeakTestCase(PillowTestCase): core() mem = self._get_mem_usage() - start_mem msg = "memory usage limit exceeded in iteration %d" % cycle - self.assertLess(mem, self.mem_limit, msg) + assert mem < self.mem_limit, msg # helpers diff --git a/Tests/test_color_lut.py b/Tests/test_color_lut.py index aace47d38..82a3bd1aa 100644 --- a/Tests/test_color_lut.py +++ b/Tests/test_color_lut.py @@ -1,6 +1,7 @@ import unittest from array import array +import pytest from PIL import Image, ImageFilter from .helper import PillowTestCase, assert_image_equal @@ -74,10 +75,10 @@ class TestColorLut3DCoreAPI(PillowTestCase): with self.assertRaisesRegex(ValueError, r"size1D \* size2D \* size3D"): im.im.color_lut_3d("RGB", Image.LINEAR, 3, 2, 2, 2, [0, 0, 0] * 9) - with self.assertRaises(TypeError): + with pytest.raises(TypeError): im.im.color_lut_3d("RGB", Image.LINEAR, 3, 2, 2, 2, [0, 0, "0"] * 8) - with self.assertRaises(TypeError): + with pytest.raises(TypeError): im.im.color_lut_3d("RGB", Image.LINEAR, 3, 2, 2, 2, 16) def test_correct_args(self): @@ -240,14 +241,14 @@ class TestColorLut3DCoreAPI(PillowTestCase): -1, 2, 2, 2, 2, 2, ])).load() # fmt: on - self.assertEqual(transformed[0, 0], (0, 0, 255)) - self.assertEqual(transformed[50, 50], (0, 0, 255)) - self.assertEqual(transformed[255, 0], (0, 255, 255)) - self.assertEqual(transformed[205, 50], (0, 255, 255)) - self.assertEqual(transformed[0, 255], (255, 0, 0)) - self.assertEqual(transformed[50, 205], (255, 0, 0)) - self.assertEqual(transformed[255, 255], (255, 255, 0)) - self.assertEqual(transformed[205, 205], (255, 255, 0)) + assert transformed[0, 0] == (0, 0, 255) + assert transformed[50, 50] == (0, 0, 255) + assert transformed[255, 0] == (0, 255, 255) + assert transformed[205, 50] == (0, 255, 255) + assert transformed[0, 255] == (255, 0, 0) + assert transformed[50, 205] == (255, 0, 0) + assert transformed[255, 255] == (255, 255, 0) + assert transformed[205, 205] == (255, 255, 0) # fmt: off transformed = im._new(im.im.color_lut_3d('RGB', Image.LINEAR, @@ -260,14 +261,14 @@ class TestColorLut3DCoreAPI(PillowTestCase): -3, 5, 5, 5, 5, 5, ])).load() # fmt: on - self.assertEqual(transformed[0, 0], (0, 0, 255)) - self.assertEqual(transformed[50, 50], (0, 0, 255)) - self.assertEqual(transformed[255, 0], (0, 255, 255)) - self.assertEqual(transformed[205, 50], (0, 255, 255)) - self.assertEqual(transformed[0, 255], (255, 0, 0)) - self.assertEqual(transformed[50, 205], (255, 0, 0)) - self.assertEqual(transformed[255, 255], (255, 255, 0)) - self.assertEqual(transformed[205, 205], (255, 255, 0)) + assert transformed[0, 0] == (0, 0, 255) + assert transformed[50, 50] == (0, 0, 255) + assert transformed[255, 0] == (0, 255, 255) + assert transformed[205, 50] == (0, 255, 255) + assert transformed[0, 255] == (255, 0, 0) + assert transformed[50, 205] == (255, 0, 0) + assert transformed[255, 255] == (255, 255, 0) + assert transformed[205, 205] == (255, 255, 0) class TestColorLut3DFilter(PillowTestCase): @@ -301,20 +302,20 @@ class TestColorLut3DFilter(PillowTestCase): def test_convert_table(self): lut = ImageFilter.Color3DLUT(2, [0, 1, 2] * 8) - self.assertEqual(tuple(lut.size), (2, 2, 2)) - self.assertEqual(lut.name, "Color 3D LUT") + assert tuple(lut.size) == (2, 2, 2) + assert lut.name == "Color 3D LUT" # fmt: off lut = ImageFilter.Color3DLUT((2, 2, 2), [ (0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 14), (15, 16, 17), (18, 19, 20), (21, 22, 23)]) # fmt: on - self.assertEqual(tuple(lut.size), (2, 2, 2)) - self.assertEqual(lut.table, list(range(24))) + assert tuple(lut.size) == (2, 2, 2) + assert lut.table == list(range(24)) lut = ImageFilter.Color3DLUT((2, 2, 2), [(0, 1, 2, 3)] * 8, channels=4) - self.assertEqual(tuple(lut.size), (2, 2, 2)) - self.assertEqual(lut.table, list(range(4)) * 8) + assert tuple(lut.size) == (2, 2, 2) + assert lut.table == list(range(4)) * 8 @unittest.skipIf(numpy is None, "Numpy is not installed") def test_numpy_sources(self): @@ -324,30 +325,30 @@ class TestColorLut3DFilter(PillowTestCase): table = numpy.ones((7, 6, 5, 3), dtype=numpy.float16) lut = ImageFilter.Color3DLUT((5, 6, 7), table) - self.assertIsInstance(lut.table, numpy.ndarray) - self.assertEqual(lut.table.dtype, table.dtype) - self.assertEqual(lut.table.shape, (table.size,)) + assert isinstance(lut.table, numpy.ndarray) + assert lut.table.dtype == table.dtype + assert lut.table.shape == (table.size,) table = numpy.ones((7 * 6 * 5, 3), dtype=numpy.float16) lut = ImageFilter.Color3DLUT((5, 6, 7), table) - self.assertEqual(lut.table.shape, (table.size,)) + assert lut.table.shape == (table.size,) table = numpy.ones((7 * 6 * 5 * 3), dtype=numpy.float16) lut = ImageFilter.Color3DLUT((5, 6, 7), table) - self.assertEqual(lut.table.shape, (table.size,)) + assert lut.table.shape == (table.size,) # Check application Image.new("RGB", (10, 10), 0).filter(lut) # Check copy table[0] = 33 - self.assertEqual(lut.table[0], 1) + assert lut.table[0] == 1 # Check not copy table = numpy.ones((7 * 6 * 5 * 3), dtype=numpy.float16) lut = ImageFilter.Color3DLUT((5, 6, 7), table, _copy_table=False) table[0] = 33 - self.assertEqual(lut.table[0], 33) + assert lut.table[0] == 33 @unittest.skipIf(numpy is None, "Numpy is not installed") def test_numpy_formats(self): @@ -386,7 +387,7 @@ class TestColorLut3DFilter(PillowTestCase): def test_repr(self): lut = ImageFilter.Color3DLUT(2, [0, 1, 2] * 8) - self.assertEqual(repr(lut), "") + assert repr(lut) == "" lut = ImageFilter.Color3DLUT( (3, 4, 5), @@ -395,8 +396,9 @@ class TestColorLut3DFilter(PillowTestCase): target_mode="YCbCr", _copy_table=False, ) - self.assertEqual( - repr(lut), "" + assert ( + repr(lut) + == "" ) @@ -417,25 +419,25 @@ class TestGenerateColorLut3D(PillowTestCase): def test_3_channels(self): lut = ImageFilter.Color3DLUT.generate(5, lambda r, g, b: (r, g, b)) - self.assertEqual(tuple(lut.size), (5, 5, 5)) - self.assertEqual(lut.name, "Color 3D LUT") + assert tuple(lut.size) == (5, 5, 5) + assert lut.name == "Color 3D LUT" # fmt: off - self.assertEqual(lut.table[:24], [ + assert lut.table[:24] == [ 0.0, 0.0, 0.0, 0.25, 0.0, 0.0, 0.5, 0.0, 0.0, 0.75, 0.0, 0.0, - 1.0, 0.0, 0.0, 0.0, 0.25, 0.0, 0.25, 0.25, 0.0, 0.5, 0.25, 0.0]) + 1.0, 0.0, 0.0, 0.0, 0.25, 0.0, 0.25, 0.25, 0.0, 0.5, 0.25, 0.0] # fmt: on def test_4_channels(self): lut = ImageFilter.Color3DLUT.generate( 5, channels=4, callback=lambda r, g, b: (b, r, g, (r + g + b) / 2) ) - self.assertEqual(tuple(lut.size), (5, 5, 5)) - self.assertEqual(lut.name, "Color 3D LUT") + assert tuple(lut.size) == (5, 5, 5) + assert lut.name == "Color 3D LUT" # fmt: off - self.assertEqual(lut.table[:24], [ + assert lut.table[:24] == [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.25, 0.0, 0.125, 0.0, 0.5, 0.0, 0.25, 0.0, 0.75, 0.0, 0.375, 0.0, 1.0, 0.0, 0.5, 0.0, 0.0, 0.25, 0.125 - ]) + ] # fmt: on def test_apply(self): @@ -445,7 +447,7 @@ class TestGenerateColorLut3D(PillowTestCase): im = Image.merge( "RGB", [g, g.transpose(Image.ROTATE_90), g.transpose(Image.ROTATE_180)] ) - self.assertEqual(im, im.filter(lut)) + assert im == im.filter(lut) class TestTransformColorLut3D(PillowTestCase): @@ -461,7 +463,7 @@ class TestTransformColorLut3D(PillowTestCase): with self.assertRaisesRegex(ValueError, "should have either channels"): source.transform(lambda r, g, b: (r, g, b, 1)) - with self.assertRaises(TypeError): + with pytest.raises(TypeError): source.transform(lambda r, g, b, a: (r, g, b)) def test_target_mode(self): @@ -470,31 +472,29 @@ class TestTransformColorLut3D(PillowTestCase): ) lut = source.transform(lambda r, g, b: (r, g, b)) - self.assertEqual(lut.mode, "HSV") + assert lut.mode == "HSV" lut = source.transform(lambda r, g, b: (r, g, b), target_mode="RGB") - self.assertEqual(lut.mode, "RGB") + assert lut.mode == "RGB" def test_3_to_3_channels(self): source = ImageFilter.Color3DLUT.generate((3, 4, 5), lambda r, g, b: (r, g, b)) lut = source.transform(lambda r, g, b: (r * r, g * g, b * b)) - self.assertEqual(tuple(lut.size), tuple(source.size)) - self.assertEqual(len(lut.table), len(source.table)) - self.assertNotEqual(lut.table, source.table) - self.assertEqual( - lut.table[0:10], [0.0, 0.0, 0.0, 0.25, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0] - ) + assert tuple(lut.size) == tuple(source.size) + assert len(lut.table) == len(source.table) + assert lut.table != source.table + assert lut.table[0:10] == [0.0, 0.0, 0.0, 0.25, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0] def test_3_to_4_channels(self): source = ImageFilter.Color3DLUT.generate((6, 5, 4), lambda r, g, b: (r, g, b)) lut = source.transform(lambda r, g, b: (r * r, g * g, b * b, 1), channels=4) - self.assertEqual(tuple(lut.size), tuple(source.size)) - self.assertNotEqual(len(lut.table), len(source.table)) - self.assertNotEqual(lut.table, source.table) + assert tuple(lut.size) == tuple(source.size) + assert len(lut.table) != len(source.table) + assert lut.table != source.table # fmt: off - self.assertEqual(lut.table[0:16], [ + assert lut.table[0:16] == [ 0.0, 0.0, 0.0, 1, 0.2**2, 0.0, 0.0, 1, - 0.4**2, 0.0, 0.0, 1, 0.6**2, 0.0, 0.0, 1]) + 0.4**2, 0.0, 0.0, 1, 0.6**2, 0.0, 0.0, 1] # fmt: on def test_4_to_3_channels(self): @@ -504,13 +504,13 @@ class TestTransformColorLut3D(PillowTestCase): lut = source.transform( lambda r, g, b, a: (a - r * r, a - g * g, a - b * b), channels=3 ) - self.assertEqual(tuple(lut.size), tuple(source.size)) - self.assertNotEqual(len(lut.table), len(source.table)) - self.assertNotEqual(lut.table, source.table) + assert tuple(lut.size) == tuple(source.size) + assert len(lut.table) != len(source.table) + assert lut.table != source.table # fmt: off - self.assertEqual(lut.table[0:18], [ + assert lut.table[0:18] == [ 1.0, 1.0, 1.0, 0.75, 1.0, 1.0, 0.0, 1.0, 1.0, - 1.0, 0.96, 1.0, 0.75, 0.96, 1.0, 0.0, 0.96, 1.0]) + 1.0, 0.96, 1.0, 0.75, 0.96, 1.0, 0.0, 0.96, 1.0] # fmt: on def test_4_to_4_channels(self): @@ -518,13 +518,13 @@ class TestTransformColorLut3D(PillowTestCase): (6, 5, 4), lambda r, g, b: (r, g, b, 1), channels=4 ) lut = source.transform(lambda r, g, b, a: (r * r, g * g, b * b, a - 0.5)) - self.assertEqual(tuple(lut.size), tuple(source.size)) - self.assertEqual(len(lut.table), len(source.table)) - self.assertNotEqual(lut.table, source.table) + assert tuple(lut.size) == tuple(source.size) + assert len(lut.table) == len(source.table) + assert lut.table != source.table # fmt: off - self.assertEqual(lut.table[0:16], [ + assert lut.table[0:16] == [ 0.0, 0.0, 0.0, 0.5, 0.2**2, 0.0, 0.0, 0.5, - 0.4**2, 0.0, 0.0, 0.5, 0.6**2, 0.0, 0.0, 0.5]) + 0.4**2, 0.0, 0.0, 0.5, 0.6**2, 0.0, 0.0, 0.5] # fmt: on def test_with_normals_3_channels(self): @@ -534,13 +534,13 @@ class TestTransformColorLut3D(PillowTestCase): lut = source.transform( lambda nr, ng, nb, r, g, b: (nr - r, ng - g, nb - b), with_normals=True ) - self.assertEqual(tuple(lut.size), tuple(source.size)) - self.assertEqual(len(lut.table), len(source.table)) - self.assertNotEqual(lut.table, source.table) + assert tuple(lut.size) == tuple(source.size) + assert len(lut.table) == len(source.table) + assert lut.table != source.table # fmt: off - self.assertEqual(lut.table[0:18], [ + assert lut.table[0:18] == [ 0.0, 0.0, 0.0, 0.16, 0.0, 0.0, 0.24, 0.0, 0.0, - 0.24, 0.0, 0.0, 0.8 - (0.8**2), 0, 0, 0, 0, 0]) + 0.24, 0.0, 0.0, 0.8 - (0.8**2), 0, 0, 0, 0, 0] # fmt: on def test_with_normals_4_channels(self): @@ -551,11 +551,11 @@ class TestTransformColorLut3D(PillowTestCase): lambda nr, ng, nb, r, g, b, a: (nr - r, ng - g, nb - b, a - 0.5), with_normals=True, ) - self.assertEqual(tuple(lut.size), tuple(source.size)) - self.assertEqual(len(lut.table), len(source.table)) - self.assertNotEqual(lut.table, source.table) + assert tuple(lut.size) == tuple(source.size) + assert len(lut.table) == len(source.table) + assert lut.table != source.table # fmt: off - self.assertEqual(lut.table[0:16], [ + assert lut.table[0:16] == [ 0.0, 0.0, 0.0, 0.5, 0.25, 0.0, 0.0, 0.5, - 0.0, 0.0, 0.0, 0.5, 0.0, 0.16, 0.0, 0.5]) + 0.0, 0.0, 0.0, 0.5, 0.0, 0.16, 0.0, 0.5] # fmt: on diff --git a/Tests/test_core_resources.py b/Tests/test_core_resources.py index 22563b92a..3b3ebc59f 100644 --- a/Tests/test_core_resources.py +++ b/Tests/test_core_resources.py @@ -43,38 +43,44 @@ class TestCoreMemory(PillowTestCase): def test_get_alignment(self): alignment = Image.core.get_alignment() - self.assertGreater(alignment, 0) + assert alignment > 0 def test_set_alignment(self): for i in [1, 2, 4, 8, 16, 32]: Image.core.set_alignment(i) alignment = Image.core.get_alignment() - self.assertEqual(alignment, i) + assert alignment == i # Try to construct new image Image.new("RGB", (10, 10)) - self.assertRaises(ValueError, Image.core.set_alignment, 0) - self.assertRaises(ValueError, Image.core.set_alignment, -1) - self.assertRaises(ValueError, Image.core.set_alignment, 3) + with pytest.raises(ValueError): + Image.core.set_alignment(0) + with pytest.raises(ValueError): + Image.core.set_alignment(-1) + with pytest.raises(ValueError): + Image.core.set_alignment(3) def test_get_block_size(self): block_size = Image.core.get_block_size() - self.assertGreaterEqual(block_size, 4096) + assert block_size >= 4096 def test_set_block_size(self): for i in [4096, 2 * 4096, 3 * 4096]: Image.core.set_block_size(i) block_size = Image.core.get_block_size() - self.assertEqual(block_size, i) + assert block_size == i # Try to construct new image Image.new("RGB", (10, 10)) - self.assertRaises(ValueError, Image.core.set_block_size, 0) - self.assertRaises(ValueError, Image.core.set_block_size, -1) - self.assertRaises(ValueError, Image.core.set_block_size, 4000) + with pytest.raises(ValueError): + Image.core.set_block_size(0) + with pytest.raises(ValueError): + Image.core.set_block_size(-1) + with pytest.raises(ValueError): + Image.core.set_block_size(4000) def test_set_block_size_stats(self): Image.core.reset_stats() @@ -83,28 +89,30 @@ class TestCoreMemory(PillowTestCase): Image.new("RGB", (256, 256)) stats = Image.core.get_stats() - self.assertGreaterEqual(stats["new_count"], 1) - self.assertGreaterEqual(stats["allocated_blocks"], 64) + assert stats["new_count"] >= 1 + assert stats["allocated_blocks"] >= 64 if not is_pypy(): - self.assertGreaterEqual(stats["freed_blocks"], 64) + assert stats["freed_blocks"] >= 64 def test_get_blocks_max(self): blocks_max = Image.core.get_blocks_max() - self.assertGreaterEqual(blocks_max, 0) + assert blocks_max >= 0 def test_set_blocks_max(self): for i in [0, 1, 10]: Image.core.set_blocks_max(i) blocks_max = Image.core.get_blocks_max() - self.assertEqual(blocks_max, i) + assert blocks_max == i # Try to construct new image Image.new("RGB", (10, 10)) - self.assertRaises(ValueError, Image.core.set_blocks_max, -1) + with pytest.raises(ValueError): + Image.core.set_blocks_max(-1) if sys.maxsize < 2 ** 32: - self.assertRaises(ValueError, Image.core.set_blocks_max, 2 ** 29) + with pytest.raises(ValueError): + Image.core.set_blocks_max(2 ** 29) @unittest.skipIf(is_pypy(), "images are not collected") def test_set_blocks_max_stats(self): @@ -115,11 +123,11 @@ class TestCoreMemory(PillowTestCase): Image.new("RGB", (256, 256)) stats = Image.core.get_stats() - self.assertGreaterEqual(stats["new_count"], 2) - self.assertGreaterEqual(stats["allocated_blocks"], 64) - self.assertGreaterEqual(stats["reused_blocks"], 64) - self.assertEqual(stats["freed_blocks"], 0) - self.assertEqual(stats["blocks_cached"], 64) + assert stats["new_count"] >= 2 + assert stats["allocated_blocks"] >= 64 + assert stats["reused_blocks"] >= 64 + assert stats["freed_blocks"] == 0 + assert stats["blocks_cached"] == 64 @unittest.skipIf(is_pypy(), "images are not collected") def test_clear_cache_stats(self): @@ -133,11 +141,11 @@ class TestCoreMemory(PillowTestCase): Image.core.clear_cache(16) stats = Image.core.get_stats() - self.assertGreaterEqual(stats["new_count"], 2) - self.assertGreaterEqual(stats["allocated_blocks"], 64) - self.assertGreaterEqual(stats["reused_blocks"], 64) - self.assertGreaterEqual(stats["freed_blocks"], 48) - self.assertEqual(stats["blocks_cached"], 16) + assert stats["new_count"] >= 2 + assert stats["allocated_blocks"] >= 64 + assert stats["reused_blocks"] >= 64 + assert stats["freed_blocks"] >= 48 + assert stats["blocks_cached"] == 16 def test_large_images(self): Image.core.reset_stats() @@ -147,12 +155,12 @@ class TestCoreMemory(PillowTestCase): Image.core.clear_cache() stats = Image.core.get_stats() - self.assertGreaterEqual(stats["new_count"], 1) - self.assertGreaterEqual(stats["allocated_blocks"], 16) - self.assertGreaterEqual(stats["reused_blocks"], 0) - self.assertEqual(stats["blocks_cached"], 0) + assert stats["new_count"] >= 1 + assert stats["allocated_blocks"] >= 16 + assert stats["reused_blocks"] >= 0 + assert stats["blocks_cached"] == 0 if not is_pypy(): - self.assertGreaterEqual(stats["freed_blocks"], 16) + assert stats["freed_blocks"] >= 16 class TestEnvVars(PillowTestCase): @@ -165,9 +173,9 @@ class TestEnvVars(PillowTestCase): def test_units(self): Image._apply_env_variables({"PILLOW_BLOCKS_MAX": "2K"}) - self.assertEqual(Image.core.get_blocks_max(), 2 * 1024) + assert Image.core.get_blocks_max() == 2 * 1024 Image._apply_env_variables({"PILLOW_BLOCK_SIZE": "2m"}) - self.assertEqual(Image.core.get_block_size(), 2 * 1024 * 1024) + assert Image.core.get_block_size() == 2 * 1024 * 1024 def test_warnings(self): pytest.warns( diff --git a/Tests/test_file_eps.py b/Tests/test_file_eps.py index 77fbe9c4d..af980b94a 100644 --- a/Tests/test_file_eps.py +++ b/Tests/test_file_eps.py @@ -1,6 +1,7 @@ import io import unittest +import pytest from PIL import EpsImagePlugin, Image, features from .helper import PillowTestCase, assert_image_similar, hopper, skip_unless_feature @@ -28,44 +29,45 @@ class TestFileEps(PillowTestCase): # Regular scale with Image.open(file1) as image1: image1.load() - self.assertEqual(image1.mode, "RGB") - self.assertEqual(image1.size, (460, 352)) - self.assertEqual(image1.format, "EPS") + assert image1.mode == "RGB" + assert image1.size == (460, 352) + assert image1.format == "EPS" with Image.open(file2) as image2: image2.load() - self.assertEqual(image2.mode, "RGB") - self.assertEqual(image2.size, (360, 252)) - self.assertEqual(image2.format, "EPS") + assert image2.mode == "RGB" + assert image2.size == (360, 252) + assert image2.format == "EPS" # Double scale with Image.open(file1) as image1_scale2: image1_scale2.load(scale=2) - self.assertEqual(image1_scale2.mode, "RGB") - self.assertEqual(image1_scale2.size, (920, 704)) - self.assertEqual(image1_scale2.format, "EPS") + assert image1_scale2.mode == "RGB" + assert image1_scale2.size == (920, 704) + assert image1_scale2.format == "EPS" with Image.open(file2) as image2_scale2: image2_scale2.load(scale=2) - self.assertEqual(image2_scale2.mode, "RGB") - self.assertEqual(image2_scale2.size, (720, 504)) - self.assertEqual(image2_scale2.format, "EPS") + assert image2_scale2.mode == "RGB" + assert image2_scale2.size == (720, 504) + assert image2_scale2.format == "EPS" def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(SyntaxError, EpsImagePlugin.EpsImageFile, invalid_file) + with pytest.raises(SyntaxError): + EpsImagePlugin.EpsImageFile(invalid_file) @unittest.skipUnless(HAS_GHOSTSCRIPT, "Ghostscript not available") def test_cmyk(self): with Image.open("Tests/images/pil_sample_cmyk.eps") as cmyk_image: - self.assertEqual(cmyk_image.mode, "CMYK") - self.assertEqual(cmyk_image.size, (100, 100)) - self.assertEqual(cmyk_image.format, "EPS") + assert cmyk_image.mode == "CMYK" + assert cmyk_image.size == (100, 100) + assert cmyk_image.format == "EPS" cmyk_image.load() - self.assertEqual(cmyk_image.mode, "RGB") + assert cmyk_image.mode == "RGB" if features.check("jpg"): with Image.open("Tests/images/pil_sample_rgb.jpg") as target: @@ -111,7 +113,8 @@ class TestFileEps(PillowTestCase): def test_image_mode_not_supported(self): im = hopper("RGBA") tmpfile = self.tempfile("temp.eps") - self.assertRaises(ValueError, im.save, tmpfile) + with pytest.raises(ValueError): + im.save(tmpfile) @unittest.skipUnless(HAS_GHOSTSCRIPT, "Ghostscript not available") @skip_unless_feature("zlib") @@ -162,7 +165,7 @@ class TestFileEps(PillowTestCase): with Image.open(fn) as im: new_size = (100, 100) im = im.resize(new_size) - self.assertEqual(im.size, new_size) + assert im.size == new_size @unittest.skipUnless(HAS_GHOSTSCRIPT, "Ghostscript not available") def test_thumbnail(self): @@ -173,7 +176,7 @@ class TestFileEps(PillowTestCase): with Image.open(file1) as im: new_size = (100, 100) im.thumbnail(new_size) - self.assertEqual(max(im.size), max(new_size)) + assert max(im.size) == max(new_size) def test_read_binary_preview(self): # Issue 302 @@ -185,10 +188,10 @@ class TestFileEps(PillowTestCase): ending = "Failure with line ending: %s" % ( "".join("%s" % ord(s) for s in ending) ) - self.assertEqual(t.readline().strip("\r\n"), "something", ending) - self.assertEqual(t.readline().strip("\r\n"), "else", ending) - self.assertEqual(t.readline().strip("\r\n"), "baz", ending) - self.assertEqual(t.readline().strip("\r\n"), "bif", ending) + assert t.readline().strip("\r\n") == "something", ending + assert t.readline().strip("\r\n") == "else", ending + assert t.readline().strip("\r\n") == "baz", ending + assert t.readline().strip("\r\n") == "bif", ending def _test_readline_io_psfile(self, test_string, ending): f = io.BytesIO(test_string.encode("latin-1")) @@ -228,7 +231,7 @@ class TestFileEps(PillowTestCase): # Act / Assert for filename in FILES: with Image.open(filename) as img: - self.assertEqual(img.mode, "RGB") + assert img.mode == "RGB" @unittest.skipUnless(HAS_GHOSTSCRIPT, "Ghostscript not available") def test_emptyline(self): @@ -237,6 +240,6 @@ class TestFileEps(PillowTestCase): with Image.open(emptyline_file) as image: image.load() - self.assertEqual(image.mode, "RGB") - self.assertEqual(image.size, (460, 352)) - self.assertEqual(image.format, "EPS") + assert image.mode == "RGB" + assert image.size == (460, 352) + assert image.format == "EPS" diff --git a/Tests/test_file_gif.py b/Tests/test_file_gif.py index 7da1b9d05..096aa872c 100644 --- a/Tests/test_file_gif.py +++ b/Tests/test_file_gif.py @@ -24,10 +24,10 @@ class TestFileGif(PillowTestCase): def test_sanity(self): with Image.open(TEST_GIF) as im: im.load() - self.assertEqual(im.mode, "P") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "GIF") - self.assertEqual(im.info["version"], b"GIF89a") + assert im.mode == "P" + assert im.size == (128, 128) + assert im.format == "GIF" + assert im.info["version"] == b"GIF89a" @unittest.skipIf(is_pypy(), "Requires CPython") def test_unclosed_file(self): @@ -55,7 +55,8 @@ class TestFileGif(PillowTestCase): def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(SyntaxError, GifImagePlugin.GifImageFile, invalid_file) + with pytest.raises(SyntaxError): + GifImagePlugin.GifImageFile(invalid_file) def test_optimize(self): def test_grayscale(optimize): @@ -70,10 +71,10 @@ class TestFileGif(PillowTestCase): im.save(test_file, "GIF", optimize=optimize) return len(test_file.getvalue()) - self.assertEqual(test_grayscale(0), 800) - self.assertEqual(test_grayscale(1), 44) - self.assertEqual(test_bilevel(0), 800) - self.assertEqual(test_bilevel(1), 800) + assert test_grayscale(0) == 800 + assert test_grayscale(1) == 44 + assert test_bilevel(0) == 800 + assert test_bilevel(1) == 800 def test_optimize_correctness(self): # 256 color Palette image, posterize to > 128 and < 128 levels @@ -94,7 +95,7 @@ class TestFileGif(PillowTestCase): palette_length = max( i + 1 for i, v in enumerate(reloaded.histogram()) if v ) - self.assertEqual(expected_palette_length, palette_length) + assert expected_palette_length == palette_length assert_image_equal(im.convert("RGB"), reloaded.convert("RGB")) @@ -117,7 +118,7 @@ class TestFileGif(PillowTestCase): im = Image.frombytes("L", (16, 16), bytes(range(256))) test_file = BytesIO() im.save(test_file, "GIF", optimize=True) - self.assertEqual(im.mode, "L") + assert im.mode == "L" def test_roundtrip(self): out = self.tempfile("temp.gif") @@ -153,7 +154,7 @@ class TestFileGif(PillowTestCase): im.save(out, save_all=True) with Image.open(out) as reread: - self.assertEqual(reread.n_frames, 5) + assert reread.n_frames == 5 def test_headers_saving_for_animated_gifs(self): important_headers = ["background", "version", "duration", "loop"] @@ -167,7 +168,7 @@ class TestFileGif(PillowTestCase): with Image.open(out) as reread: for header in important_headers: - self.assertEqual(info[header], reread.info[header]) + assert info[header] == reread.info[header] def test_palette_handling(self): # see https://github.com/python-pillow/Pillow/issues/513 @@ -237,7 +238,7 @@ class TestFileGif(PillowTestCase): framecount += 1 img.seek(img.tell() + 1) except EOFError: - self.assertEqual(framecount, 5) + assert framecount == 5 def test_seek_info(self): with Image.open("Tests/images/iss634.gif") as im: @@ -246,7 +247,7 @@ class TestFileGif(PillowTestCase): im.seek(1) im.seek(0) - self.assertEqual(im.info, info) + assert im.info == info def test_seek_rewind(self): with Image.open("Tests/images/iss634.gif") as im: @@ -261,20 +262,21 @@ class TestFileGif(PillowTestCase): for path, n_frames in [[TEST_GIF, 1], ["Tests/images/iss634.gif", 42]]: # Test is_animated before n_frames with Image.open(path) as im: - self.assertEqual(im.is_animated, n_frames != 1) + assert im.is_animated == (n_frames != 1) # Test is_animated after n_frames with Image.open(path) as im: - self.assertEqual(im.n_frames, n_frames) - self.assertEqual(im.is_animated, n_frames != 1) + assert im.n_frames == n_frames + assert im.is_animated == (n_frames != 1) def test_eoferror(self): with Image.open(TEST_GIF) as im: n_frames = im.n_frames # Test seeking past the last frame - self.assertRaises(EOFError, im.seek, n_frames) - self.assertLess(im.tell(), n_frames) + with pytest.raises(EOFError): + im.seek(n_frames) + assert im.tell() < n_frames # Test that seeking to the last frame does not raise an error im.seek(n_frames - 1) @@ -284,7 +286,7 @@ class TestFileGif(PillowTestCase): try: while True: img.seek(img.tell() + 1) - self.assertEqual(img.disposal_method, 1) + assert img.disposal_method == 1 except EOFError: pass @@ -293,7 +295,7 @@ class TestFileGif(PillowTestCase): try: while True: img.seek(img.tell() + 1) - self.assertEqual(img.disposal_method, 2) + assert img.disposal_method == 2 except EOFError: pass @@ -302,7 +304,7 @@ class TestFileGif(PillowTestCase): try: while True: img.seek(img.tell() + 1) - self.assertEqual(img.disposal_method, 3) + assert img.disposal_method == 3 except EOFError: pass @@ -320,7 +322,7 @@ class TestFileGif(PillowTestCase): with Image.open(out) as img: for _ in range(2): img.seek(img.tell() + 1) - self.assertEqual(img.disposal_method, method) + assert img.disposal_method == method # check per frame disposal im_list[0].save( @@ -334,7 +336,7 @@ class TestFileGif(PillowTestCase): for i in range(2): img.seek(img.tell() + 1) - self.assertEqual(img.disposal_method, i + 1) + assert img.disposal_method == i + 1 def test_dispose2_palette(self): out = self.tempfile("temp.gif") @@ -360,10 +362,10 @@ class TestFileGif(PillowTestCase): rgb_img = img.convert("RGB") # Check top left pixel matches background - self.assertEqual(rgb_img.getpixel((0, 0)), (255, 0, 0)) + assert rgb_img.getpixel((0, 0)) == (255, 0, 0) # Center remains red every frame - self.assertEqual(rgb_img.getpixel((50, 50)), circle) + assert rgb_img.getpixel((50, 50)) == circle def test_dispose2_diff(self): out = self.tempfile("temp.gif") @@ -398,13 +400,13 @@ class TestFileGif(PillowTestCase): rgb_img = img.convert("RGBA") # Check left circle is correct colour - self.assertEqual(rgb_img.getpixel((20, 50)), colours[0]) + assert rgb_img.getpixel((20, 50)) == colours[0] # Check right circle is correct colour - self.assertEqual(rgb_img.getpixel((80, 50)), colours[1]) + assert rgb_img.getpixel((80, 50)) == colours[1] # Check BG is correct colour - self.assertEqual(rgb_img.getpixel((1, 1)), (255, 255, 255, 0)) + assert rgb_img.getpixel((1, 1)) == (255, 255, 255, 0) def test_dispose2_background(self): out = self.tempfile("temp.gif") @@ -429,7 +431,7 @@ class TestFileGif(PillowTestCase): with Image.open(out) as im: im.seek(1) - self.assertEqual(im.getpixel((0, 0)), 0) + assert im.getpixel((0, 0)) == 0 def test_iss634(self): with Image.open("Tests/images/iss634.gif") as img: @@ -437,7 +439,7 @@ class TestFileGif(PillowTestCase): img.seek(img.tell() + 1) # all transparent pixels should be replaced with the color from the # first frame - self.assertEqual(img.histogram()[img.info["transparency"]], 0) + assert img.histogram()[img.info["transparency"]] == 0 def test_duration(self): duration = 1000 @@ -450,7 +452,7 @@ class TestFileGif(PillowTestCase): im.save(out, duration=duration) with Image.open(out) as reread: - self.assertEqual(reread.info["duration"], duration) + assert reread.info["duration"] == duration def test_multiple_duration(self): duration_list = [1000, 2000, 3000] @@ -469,7 +471,7 @@ class TestFileGif(PillowTestCase): with Image.open(out) as reread: for duration in duration_list: - self.assertEqual(reread.info["duration"], duration) + assert reread.info["duration"] == duration try: reread.seek(reread.tell() + 1) except EOFError: @@ -482,7 +484,7 @@ class TestFileGif(PillowTestCase): with Image.open(out) as reread: for duration in duration_list: - self.assertEqual(reread.info["duration"], duration) + assert reread.info["duration"] == duration try: reread.seek(reread.tell() + 1) except EOFError: @@ -506,10 +508,10 @@ class TestFileGif(PillowTestCase): with Image.open(out) as reread: # Assert that the first three frames were combined - self.assertEqual(reread.n_frames, 2) + assert reread.n_frames == 2 # Assert that the new duration is the total of the identical frames - self.assertEqual(reread.info["duration"], 4500) + assert reread.info["duration"] == 4500 def test_identical_frames_to_single_frame(self): for duration in ([1000, 1500, 2000, 4000], (1000, 1500, 2000, 4000), 8500): @@ -525,10 +527,10 @@ class TestFileGif(PillowTestCase): ) with Image.open(out) as reread: # Assert that all frames were combined - self.assertEqual(reread.n_frames, 1) + assert reread.n_frames == 1 # Assert that the new duration is the total of the identical frames - self.assertEqual(reread.info["duration"], 8500) + assert reread.info["duration"] == 8500 def test_number_of_loops(self): number_of_loops = 2 @@ -538,7 +540,7 @@ class TestFileGif(PillowTestCase): im.save(out, loop=number_of_loops) with Image.open(out) as reread: - self.assertEqual(reread.info["loop"], number_of_loops) + assert reread.info["loop"] == number_of_loops def test_background(self): out = self.tempfile("temp.gif") @@ -547,30 +549,28 @@ class TestFileGif(PillowTestCase): im.save(out) with Image.open(out) as reread: - self.assertEqual(reread.info["background"], im.info["background"]) + assert reread.info["background"] == im.info["background"] if features.check("webp") and features.check("webp_anim"): with Image.open("Tests/images/hopper.webp") as im: - self.assertIsInstance(im.info["background"], tuple) + assert isinstance(im.info["background"], tuple) im.save(out) def test_comment(self): with Image.open(TEST_GIF) as im: - self.assertEqual( - im.info["comment"], b"File written by Adobe Photoshop\xa8 4.0" - ) + assert im.info["comment"] == b"File written by Adobe Photoshop\xa8 4.0" out = self.tempfile("temp.gif") im = Image.new("L", (100, 100), "#000") im.info["comment"] = b"Test comment text" im.save(out) with Image.open(out) as reread: - self.assertEqual(reread.info["comment"], im.info["comment"]) + assert reread.info["comment"] == im.info["comment"] im.info["comment"] = "Test comment text" im.save(out) with Image.open(out) as reread: - self.assertEqual(reread.info["comment"], im.info["comment"].encode()) + assert reread.info["comment"] == im.info["comment"].encode() def test_comment_over_255(self): out = self.tempfile("temp.gif") @@ -582,7 +582,7 @@ class TestFileGif(PillowTestCase): im.save(out) with Image.open(out) as reread: - self.assertEqual(reread.info["comment"], comment) + assert reread.info["comment"] == comment def test_zero_comment_subblocks(self): with Image.open("Tests/images/hopper_zero_comment_subblocks.gif") as im: @@ -595,7 +595,7 @@ class TestFileGif(PillowTestCase): def assertVersionAfterSave(im, version): im.save(out) with Image.open(out) as reread: - self.assertEqual(reread.info["version"], version) + assert reread.info["version"] == version # Test that GIF87a is used by default im = Image.new("L", (100, 100), "#000") @@ -627,7 +627,7 @@ class TestFileGif(PillowTestCase): im.copy().save(out, save_all=True, append_images=ims) with Image.open(out) as reread: - self.assertEqual(reread.n_frames, 3) + assert reread.n_frames == 3 # Tests appending using a generator def imGenerator(ims): @@ -636,7 +636,7 @@ class TestFileGif(PillowTestCase): im.save(out, save_all=True, append_images=imGenerator(ims)) with Image.open(out) as reread: - self.assertEqual(reread.n_frames, 3) + assert reread.n_frames == 3 # Tests appending single and multiple frame images with Image.open("Tests/images/dispose_none.gif") as im: @@ -644,7 +644,7 @@ class TestFileGif(PillowTestCase): im.save(out, save_all=True, append_images=[im2]) with Image.open(out) as reread: - self.assertEqual(reread.n_frames, 10) + assert reread.n_frames == 10 def test_transparent_optimize(self): # from issue #2195, if the transparent color is incorrectly @@ -664,7 +664,7 @@ class TestFileGif(PillowTestCase): im.save(out, transparency=253) with Image.open(out) as reloaded: - self.assertEqual(reloaded.info["transparency"], 253) + assert reloaded.info["transparency"] == 253 def test_rgb_transparency(self): out = self.tempfile("temp.gif") @@ -675,7 +675,7 @@ class TestFileGif(PillowTestCase): pytest.warns(UserWarning, im.save, out) with Image.open(out) as reloaded: - self.assertNotIn("transparency", reloaded.info) + assert "transparency" not in reloaded.info # Multiple frames im = Image.new("RGB", (1, 1)) @@ -684,7 +684,7 @@ class TestFileGif(PillowTestCase): pytest.warns(UserWarning, im.save, out, save_all=True, append_images=ims) with Image.open(out) as reloaded: - self.assertNotIn("transparency", reloaded.info) + assert "transparency" not in reloaded.info def test_bbox(self): out = self.tempfile("temp.gif") @@ -694,7 +694,7 @@ class TestFileGif(PillowTestCase): im.save(out, save_all=True, append_images=ims) with Image.open(out) as reread: - self.assertEqual(reread.n_frames, 2) + assert reread.n_frames == 2 def test_palette_save_L(self): # generate an L mode image with a separate palette @@ -772,20 +772,20 @@ class TestFileGif(PillowTestCase): with open("Tests/images/gif_header_data.pkl", "rb") as f: (h_target, d_target) = pickle.load(f) - self.assertEqual(h, h_target) - self.assertEqual(d, d_target) + assert h == h_target + assert d == d_target finally: GifImagePlugin._FORCE_OPTIMIZE = False def test_lzw_bits(self): # see https://github.com/python-pillow/Pillow/issues/2811 with Image.open("Tests/images/issue_2811.gif") as im: - self.assertEqual(im.tile[0][3][0], 11) # LZW bits + assert im.tile[0][3][0] == 11 # LZW bits # codec error prepatch im.load() def test_extents(self): with Image.open("Tests/images/test_extents.gif") as im: - self.assertEqual(im.size, (100, 100)) + assert im.size == (100, 100) im.seek(1) - self.assertEqual(im.size, (150, 150)) + assert im.size == (150, 150) diff --git a/Tests/test_file_icns.py b/Tests/test_file_icns.py index 5693a19fd..855cc9e08 100644 --- a/Tests/test_file_icns.py +++ b/Tests/test_file_icns.py @@ -22,9 +22,9 @@ class TestFileIcns(PillowTestCase): # Assert that there is no unclosed file warning pytest.warns(None, im.load) - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (1024, 1024)) - self.assertEqual(im.format, "ICNS") + assert im.mode == "RGBA" + assert im.size == (1024, 1024) + assert im.format == "ICNS" @unittest.skipIf(sys.platform != "darwin", "requires macOS") def test_save(self): @@ -34,9 +34,9 @@ class TestFileIcns(PillowTestCase): im.save(temp_file) with Image.open(temp_file) as reread: - self.assertEqual(reread.mode, "RGBA") - self.assertEqual(reread.size, (1024, 1024)) - self.assertEqual(reread.format, "ICNS") + assert reread.mode == "RGBA" + assert reread.size == (1024, 1024) + assert reread.format == "ICNS" @unittest.skipIf(sys.platform != "darwin", "requires macOS") def test_save_append_images(self): @@ -63,11 +63,11 @@ class TestFileIcns(PillowTestCase): hr = h * r im.size = (w, h, r) im.load() - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (wr, hr)) + assert im.mode == "RGBA" + assert im.size == (wr, hr) # Check that we cannot load an incorrect size - with self.assertRaises(ValueError): + with pytest.raises(ValueError): im.size = (1, 1) def test_older_icon(self): @@ -80,8 +80,8 @@ class TestFileIcns(PillowTestCase): with Image.open("Tests/images/pillow2.icns") as im2: im2.size = (w, h, r) im2.load() - self.assertEqual(im2.mode, "RGBA") - self.assertEqual(im2.size, (wr, hr)) + assert im2.mode == "RGBA" + assert im2.size == (wr, hr) def test_jp2_icon(self): # This icon was made by using Uli Kusterer's oldiconutil to replace @@ -101,21 +101,22 @@ class TestFileIcns(PillowTestCase): with Image.open("Tests/images/pillow3.icns") as im2: im2.size = (w, h, r) im2.load() - self.assertEqual(im2.mode, "RGBA") - self.assertEqual(im2.size, (wr, hr)) + assert im2.mode == "RGBA" + assert im2.size == (wr, hr) def test_getimage(self): with open(TEST_FILE, "rb") as fp: icns_file = IcnsImagePlugin.IcnsFile(fp) im = icns_file.getimage() - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (1024, 1024)) + assert im.mode == "RGBA" + assert im.size == (1024, 1024) im = icns_file.getimage((512, 512)) - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (512, 512)) + assert im.mode == "RGBA" + assert im.size == (512, 512) def test_not_an_icns_file(self): with io.BytesIO(b"invalid\n") as fp: - self.assertRaises(SyntaxError, IcnsImagePlugin.IcnsFile, fp) + with pytest.raises(SyntaxError): + IcnsImagePlugin.IcnsFile(fp) diff --git a/Tests/test_file_ico.py b/Tests/test_file_ico.py index 47fae7ed9..822b07532 100644 --- a/Tests/test_file_ico.py +++ b/Tests/test_file_ico.py @@ -12,14 +12,15 @@ class TestFileIco(PillowTestCase): def test_sanity(self): with Image.open(TEST_ICO_FILE) as im: im.load() - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (16, 16)) - self.assertEqual(im.format, "ICO") - self.assertEqual(im.get_format_mimetype(), "image/x-icon") + assert im.mode == "RGBA" + assert im.size == (16, 16) + assert im.format == "ICO" + assert im.get_format_mimetype() == "image/x-icon" def test_invalid_file(self): with open("Tests/images/flower.jpg", "rb") as fp: - self.assertRaises(SyntaxError, IcoImagePlugin.IcoImageFile, fp) + with pytest.raises(SyntaxError): + IcoImagePlugin.IcoImageFile(fp) def test_save_to_bytes(self): output = io.BytesIO() @@ -29,11 +30,11 @@ class TestFileIco(PillowTestCase): # the default image output.seek(0) with Image.open(output) as reloaded: - self.assertEqual(reloaded.info["sizes"], {(32, 32), (64, 64)}) + assert reloaded.info["sizes"] == {(32, 32), (64, 64)} - self.assertEqual(im.mode, reloaded.mode) - self.assertEqual((64, 64), reloaded.size) - self.assertEqual(reloaded.format, "ICO") + assert im.mode == reloaded.mode + assert (64, 64) == reloaded.size + assert reloaded.format == "ICO" assert_image_equal(reloaded, hopper().resize((64, 64), Image.LANCZOS)) # the other one @@ -41,14 +42,14 @@ class TestFileIco(PillowTestCase): with Image.open(output) as reloaded: reloaded.size = (32, 32) - self.assertEqual(im.mode, reloaded.mode) - self.assertEqual((32, 32), reloaded.size) - self.assertEqual(reloaded.format, "ICO") + assert im.mode == reloaded.mode + assert (32, 32) == reloaded.size + assert reloaded.format == "ICO" assert_image_equal(reloaded, hopper().resize((32, 32), Image.LANCZOS)) def test_incorrect_size(self): with Image.open(TEST_ICO_FILE) as im: - with self.assertRaises(ValueError): + with pytest.raises(ValueError): im.size = (1, 1) def test_save_256x256(self): @@ -62,7 +63,7 @@ class TestFileIco(PillowTestCase): with Image.open(outfile) as im_saved: # Assert - self.assertEqual(im_saved.size, (256, 256)) + assert im_saved.size == (256, 256) def test_only_save_relevant_sizes(self): """Issue #2266 https://github.com/python-pillow/Pillow/issues/2266 @@ -77,16 +78,14 @@ class TestFileIco(PillowTestCase): with Image.open(outfile) as im_saved: # Assert - self.assertEqual( - im_saved.info["sizes"], {(16, 16), (24, 24), (32, 32), (48, 48)} - ) + assert im_saved.info["sizes"] == {(16, 16), (24, 24), (32, 32), (48, 48)} def test_unexpected_size(self): # This image has been manually hexedited to state that it is 16x32 # while the image within is still 16x16 def open(): with Image.open("Tests/images/hopper_unexpected.ico") as im: - self.assertEqual(im.size, (16, 16)) + assert im.size == (16, 16) pytest.warns(UserWarning, open) diff --git a/Tests/test_file_jpeg.py b/Tests/test_file_jpeg.py index a2a848b41..be1188a63 100644 --- a/Tests/test_file_jpeg.py +++ b/Tests/test_file_jpeg.py @@ -46,21 +46,20 @@ class TestFileJpeg(PillowTestCase): with Image.open(TEST_FILE) as im: im.load() - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "JPEG") - self.assertEqual(im.get_format_mimetype(), "image/jpeg") + assert im.mode == "RGB" + assert im.size == (128, 128) + assert im.format == "JPEG" + assert im.get_format_mimetype() == "image/jpeg" def test_app(self): # Test APP/COM reader (@PIL135) with Image.open(TEST_FILE) as im: - self.assertEqual( - im.applist[0], ("APP0", b"JFIF\x00\x01\x01\x01\x00`\x00`\x00\x00") + assert im.applist[0] == ("APP0", b"JFIF\x00\x01\x01\x01\x00`\x00`\x00\x00") + assert im.applist[1] == ( + "COM", + b"File written by Adobe Photoshop\xa8 4.0\x00", ) - self.assertEqual( - im.applist[1], ("COM", b"File written by Adobe Photoshop\xa8 4.0\x00") - ) - self.assertEqual(len(im.applist), 2) + assert len(im.applist) == 2 def test_cmyk(self): # Test CMYK handling. Thanks to Tim and Charlie for test data, @@ -69,26 +68,26 @@ class TestFileJpeg(PillowTestCase): with Image.open(f) as im: # the source image has red pixels in the upper left corner. c, m, y, k = [x / 255.0 for x in im.getpixel((0, 0))] - self.assertEqual(c, 0.0) - self.assertGreater(m, 0.8) - self.assertGreater(y, 0.8) - self.assertEqual(k, 0.0) + assert c == 0.0 + assert m > 0.8 + assert y > 0.8 + assert k == 0.0 # the opposite corner is black c, m, y, k = [ x / 255.0 for x in im.getpixel((im.size[0] - 1, im.size[1] - 1)) ] - self.assertGreater(k, 0.9) + assert k > 0.9 # roundtrip, and check again im = self.roundtrip(im) c, m, y, k = [x / 255.0 for x in im.getpixel((0, 0))] - self.assertEqual(c, 0.0) - self.assertGreater(m, 0.8) - self.assertGreater(y, 0.8) - self.assertEqual(k, 0.0) + assert c == 0.0 + assert m > 0.8 + assert y > 0.8 + assert k == 0.0 c, m, y, k = [ x / 255.0 for x in im.getpixel((im.size[0] - 1, im.size[1] - 1)) ] - self.assertGreater(k, 0.9) + assert k > 0.9 def test_dpi(self): def test(xdpi, ydpi=None): @@ -96,27 +95,27 @@ class TestFileJpeg(PillowTestCase): im = self.roundtrip(im, dpi=(xdpi, ydpi or xdpi)) return im.info.get("dpi") - self.assertEqual(test(72), (72, 72)) - self.assertEqual(test(300), (300, 300)) - self.assertEqual(test(100, 200), (100, 200)) - self.assertIsNone(test(0)) # square pixels + assert test(72) == (72, 72) + assert test(300) == (300, 300) + assert test(100, 200) == (100, 200) + assert test(0) is None # square pixels def test_icc(self): # Test ICC support with Image.open("Tests/images/rgb.jpg") as im1: icc_profile = im1.info["icc_profile"] - self.assertEqual(len(icc_profile), 3144) + assert len(icc_profile) == 3144 # Roundtrip via physical file. f = self.tempfile("temp.jpg") im1.save(f, icc_profile=icc_profile) with Image.open(f) as im2: - self.assertEqual(im2.info.get("icc_profile"), icc_profile) + assert im2.info.get("icc_profile") == icc_profile # Roundtrip via memory buffer. im1 = self.roundtrip(hopper()) im2 = self.roundtrip(hopper(), icc_profile=icc_profile) assert_image_equal(im1, im2) - self.assertFalse(im1.info.get("icc_profile")) - self.assertTrue(im2.info.get("icc_profile")) + assert not im1.info.get("icc_profile") + assert im2.info.get("icc_profile") def test_icc_big(self): # Make sure that the "extra" support handles large blocks @@ -125,9 +124,9 @@ class TestFileJpeg(PillowTestCase): # using a 4-byte test code should allow us to detect out of # order issues. icc_profile = (b"Test" * int(n / 4 + 1))[:n] - self.assertEqual(len(icc_profile), n) # sanity + assert len(icc_profile) == n # sanity im1 = self.roundtrip(hopper(), icc_profile=icc_profile) - self.assertEqual(im1.info.get("icc_profile"), icc_profile or None) + assert im1.info.get("icc_profile") == (icc_profile or None) test(0) test(1) @@ -163,8 +162,8 @@ class TestFileJpeg(PillowTestCase): im3 = self.roundtrip(hopper(), optimize=1) assert_image_equal(im1, im2) assert_image_equal(im1, im3) - self.assertGreaterEqual(im1.bytes, im2.bytes) - self.assertGreaterEqual(im1.bytes, im3.bytes) + assert im1.bytes >= im2.bytes + assert im1.bytes >= im3.bytes def test_optimize_large_buffer(self): # https://github.com/python-pillow/Pillow/issues/148 @@ -177,12 +176,12 @@ class TestFileJpeg(PillowTestCase): im1 = self.roundtrip(hopper()) im2 = self.roundtrip(hopper(), progressive=False) im3 = self.roundtrip(hopper(), progressive=True) - self.assertFalse(im1.info.get("progressive")) - self.assertFalse(im2.info.get("progressive")) - self.assertTrue(im3.info.get("progressive")) + assert not im1.info.get("progressive") + assert not im2.info.get("progressive") + assert im3.info.get("progressive") assert_image_equal(im1, im3) - self.assertGreaterEqual(im1.bytes, im3.bytes) + assert im1.bytes >= im3.bytes def test_progressive_large_buffer(self): f = self.tempfile("temp.jpg") @@ -229,7 +228,7 @@ class TestFileJpeg(PillowTestCase): exif = im._getexif() # Assert - self.assertEqual(exif[gps_index], expected_exif_gps) + assert exif[gps_index] == expected_exif_gps def test_exif_rollback(self): # rolling back exif support in 3.1 to pre-3.0 formatting. @@ -264,7 +263,7 @@ class TestFileJpeg(PillowTestCase): exif = im._getexif() for tag, value in expected_exif.items(): - self.assertEqual(value, exif[tag]) + assert value == exif[tag] def test_exif_gps_typeerror(self): with Image.open("Tests/images/exif_gps_typeerror.jpg") as im: @@ -274,30 +273,30 @@ class TestFileJpeg(PillowTestCase): def test_progressive_compat(self): im1 = self.roundtrip(hopper()) - self.assertFalse(im1.info.get("progressive")) - self.assertFalse(im1.info.get("progression")) + assert not im1.info.get("progressive") + assert not im1.info.get("progression") im2 = self.roundtrip(hopper(), progressive=0) im3 = self.roundtrip(hopper(), progression=0) # compatibility - self.assertFalse(im2.info.get("progressive")) - self.assertFalse(im2.info.get("progression")) - self.assertFalse(im3.info.get("progressive")) - self.assertFalse(im3.info.get("progression")) + assert not im2.info.get("progressive") + assert not im2.info.get("progression") + assert not im3.info.get("progressive") + assert not im3.info.get("progression") im2 = self.roundtrip(hopper(), progressive=1) im3 = self.roundtrip(hopper(), progression=1) # compatibility assert_image_equal(im1, im2) assert_image_equal(im1, im3) - self.assertTrue(im2.info.get("progressive")) - self.assertTrue(im2.info.get("progression")) - self.assertTrue(im3.info.get("progressive")) - self.assertTrue(im3.info.get("progression")) + assert im2.info.get("progressive") + assert im2.info.get("progression") + assert im3.info.get("progressive") + assert im3.info.get("progression") def test_quality(self): im1 = self.roundtrip(hopper()) im2 = self.roundtrip(hopper(), quality=50) assert_image(im1, im2.mode, im2.size) - self.assertGreaterEqual(im1.bytes, im2.bytes) + assert im1.bytes >= im2.bytes def test_smooth(self): im1 = self.roundtrip(hopper()) @@ -311,35 +310,36 @@ class TestFileJpeg(PillowTestCase): # experimental API im = self.roundtrip(hopper(), subsampling=-1) # default - self.assertEqual(getsampling(im), (2, 2, 1, 1, 1, 1)) + assert getsampling(im) == (2, 2, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling=0) # 4:4:4 - self.assertEqual(getsampling(im), (1, 1, 1, 1, 1, 1)) + assert getsampling(im) == (1, 1, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling=1) # 4:2:2 - self.assertEqual(getsampling(im), (2, 1, 1, 1, 1, 1)) + assert getsampling(im) == (2, 1, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling=2) # 4:2:0 - self.assertEqual(getsampling(im), (2, 2, 1, 1, 1, 1)) + assert getsampling(im) == (2, 2, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling=3) # default (undefined) - self.assertEqual(getsampling(im), (2, 2, 1, 1, 1, 1)) + assert getsampling(im) == (2, 2, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling="4:4:4") - self.assertEqual(getsampling(im), (1, 1, 1, 1, 1, 1)) + assert getsampling(im) == (1, 1, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling="4:2:2") - self.assertEqual(getsampling(im), (2, 1, 1, 1, 1, 1)) + assert getsampling(im) == (2, 1, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling="4:2:0") - self.assertEqual(getsampling(im), (2, 2, 1, 1, 1, 1)) + assert getsampling(im) == (2, 2, 1, 1, 1, 1) im = self.roundtrip(hopper(), subsampling="4:1:1") - self.assertEqual(getsampling(im), (2, 2, 1, 1, 1, 1)) + assert getsampling(im) == (2, 2, 1, 1, 1, 1) - self.assertRaises(TypeError, self.roundtrip, hopper(), subsampling="1:1:1") + with pytest.raises(TypeError): + self.roundtrip(hopper(), subsampling="1:1:1") def test_exif(self): with Image.open("Tests/images/pil_sample_rgb.jpg") as im: info = im._getexif() - self.assertEqual(info[305], "Adobe Photoshop CS Macintosh") + assert info[305] == "Adobe Photoshop CS Macintosh" def test_mp(self): with Image.open("Tests/images/pil_sample_rgb.jpg") as im: - self.assertIsNone(im._getmp()) + assert im._getmp() is None def test_quality_keep(self): # RGB @@ -372,16 +372,16 @@ class TestFileJpeg(PillowTestCase): with Image.open(filename) as im: im.load() ImageFile.LOAD_TRUNCATED_IMAGES = False - self.assertIsNotNone(im.getbbox()) + assert im.getbbox() is not None def test_truncated_jpeg_throws_IOError(self): filename = "Tests/images/truncated_jpeg.jpg" with Image.open(filename) as im: - with self.assertRaises(IOError): + with pytest.raises(IOError): im.load() # Test that the error is raised if loaded a second time - with self.assertRaises(IOError): + with pytest.raises(IOError): im.load() def _n_qtables_helper(self, n, test_file): @@ -389,15 +389,15 @@ class TestFileJpeg(PillowTestCase): f = self.tempfile("temp.jpg") im.save(f, qtables=[[n] * 64] * n) with Image.open(f) as im: - self.assertEqual(len(im.quantization), n) + assert len(im.quantization) == n reloaded = self.roundtrip(im, qtables="keep") - self.assertEqual(im.quantization, reloaded.quantization) + assert im.quantization == reloaded.quantization def test_qtables(self): with Image.open("Tests/images/hopper.jpg") as im: qtables = im.quantization reloaded = self.roundtrip(im, qtables=qtables, subsampling=0) - self.assertEqual(im.quantization, reloaded.quantization) + assert im.quantization == reloaded.quantization assert_image_similar(im, self.roundtrip(im, qtables="web_low"), 30) assert_image_similar(im, self.roundtrip(im, qtables="web_high"), 30) assert_image_similar(im, self.roundtrip(im, qtables="keep"), 30) @@ -475,16 +475,21 @@ class TestFileJpeg(PillowTestCase): self._n_qtables_helper(4, "Tests/images/pil_sample_cmyk.jpg") # not a sequence - self.assertRaises(ValueError, self.roundtrip, im, qtables="a") + with pytest.raises(ValueError): + self.roundtrip(im, qtables="a") # sequence wrong length - self.assertRaises(ValueError, self.roundtrip, im, qtables=[]) + with pytest.raises(ValueError): + self.roundtrip(im, qtables=[]) # sequence wrong length - self.assertRaises(ValueError, self.roundtrip, im, qtables=[1, 2, 3, 4, 5]) + with pytest.raises(ValueError): + self.roundtrip(im, qtables=[1, 2, 3, 4, 5]) # qtable entry not a sequence - self.assertRaises(ValueError, self.roundtrip, im, qtables=[1]) + with pytest.raises(ValueError): + self.roundtrip(im, qtables=[1]) # qtable entry has wrong number of items - self.assertRaises(ValueError, self.roundtrip, im, qtables=[[1, 2, 3, 4]]) + with pytest.raises(ValueError): + self.roundtrip(im, qtables=[[1, 2, 3, 4]]) @unittest.skipUnless(djpeg_available(), "djpeg not available") def test_load_djpeg(self): @@ -505,8 +510,8 @@ class TestFileJpeg(PillowTestCase): tag_ids = {v: k for k, v in ExifTags.TAGS.items()} # Assert - self.assertEqual(tag_ids["RelatedImageWidth"], 0x1001) - self.assertEqual(tag_ids["RelatedImageLength"], 0x1002) + assert tag_ids["RelatedImageWidth"] == 0x1001 + assert tag_ids["RelatedImageLength"] == 0x1002 def test_MAXBLOCK_scaling(self): im = self.gen_random_image((512, 512)) @@ -529,7 +534,7 @@ class TestFileJpeg(PillowTestCase): with pytest.warns(UserWarning, Image.open, fn) as im: # Assert - self.assertEqual(im.format, "JPEG") + assert im.format == "JPEG" def test_save_correct_modes(self): out = BytesIO() @@ -542,7 +547,8 @@ class TestFileJpeg(PillowTestCase): out = BytesIO() for mode in ["LA", "La", "RGBA", "RGBa", "P"]: img = Image.new(mode, (20, 20)) - self.assertRaises(IOError, img.save, out, "JPEG") + with pytest.raises(IOError): + img.save(out, "JPEG") def test_save_tiff_with_dpi(self): # Arrange @@ -555,16 +561,16 @@ class TestFileJpeg(PillowTestCase): # Assert with Image.open(outfile) as reloaded: reloaded.load() - self.assertEqual(im.info["dpi"], reloaded.info["dpi"]) + assert im.info["dpi"] == reloaded.info["dpi"] def test_load_dpi_rounding(self): # Round up with Image.open("Tests/images/iptc_roundUp.jpg") as im: - self.assertEqual(im.info["dpi"], (44, 44)) + assert im.info["dpi"] == (44, 44) # Round down with Image.open("Tests/images/iptc_roundDown.jpg") as im: - self.assertEqual(im.info["dpi"], (2, 2)) + assert im.info["dpi"] == (2, 2) def test_save_dpi_rounding(self): outfile = self.tempfile("temp.jpg") @@ -572,12 +578,12 @@ class TestFileJpeg(PillowTestCase): im.save(outfile, dpi=(72.2, 72.2)) with Image.open(outfile) as reloaded: - self.assertEqual(reloaded.info["dpi"], (72, 72)) + assert 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)) + assert reloaded.info["dpi"] == (73, 73) def test_dpi_tuple_from_exif(self): # Arrange @@ -586,7 +592,7 @@ class TestFileJpeg(PillowTestCase): with Image.open("Tests/images/photoshop-200dpi.jpg") as im: # Act / Assert - self.assertEqual(im.info.get("dpi"), (200, 200)) + assert im.info.get("dpi") == (200, 200) def test_dpi_int_from_exif(self): # Arrange @@ -595,7 +601,7 @@ class TestFileJpeg(PillowTestCase): with Image.open("Tests/images/exif-72dpi-int.jpg") as im: # Act / Assert - self.assertEqual(im.info.get("dpi"), (72, 72)) + assert im.info.get("dpi") == (72, 72) def test_dpi_from_dpcm_exif(self): # Arrange @@ -604,7 +610,7 @@ class TestFileJpeg(PillowTestCase): with Image.open("Tests/images/exif-200dpcm.jpg") as im: # Act / Assert - self.assertEqual(im.info.get("dpi"), (508, 508)) + assert im.info.get("dpi") == (508, 508) def test_dpi_exif_zero_division(self): # Arrange @@ -614,7 +620,7 @@ class TestFileJpeg(PillowTestCase): # Act / Assert # This should return the default, and not raise a ZeroDivisionError - self.assertEqual(im.info.get("dpi"), (72, 72)) + assert im.info.get("dpi") == (72, 72) def test_no_dpi_in_exif(self): # Arrange @@ -625,7 +631,7 @@ class TestFileJpeg(PillowTestCase): # Act / Assert # "When the image resolution is unknown, 72 [dpi] is designated." # http://www.exiv2.org/tags.html - self.assertEqual(im.info.get("dpi"), (72, 72)) + assert im.info.get("dpi") == (72, 72) def test_invalid_exif(self): # This is no-dpi-in-exif with the tiff header of the exif block @@ -634,7 +640,7 @@ class TestFileJpeg(PillowTestCase): # This should return the default, and not a SyntaxError or # OSError for unidentified image. - self.assertEqual(im.info.get("dpi"), (72, 72)) + assert im.info.get("dpi") == (72, 72) def test_invalid_exif_x_resolution(self): # When no x or y resolution is defined in EXIF @@ -642,7 +648,7 @@ class TestFileJpeg(PillowTestCase): # This should return the default, and not a ValueError or # OSError for an unidentified image. - self.assertEqual(im.info.get("dpi"), (72, 72)) + assert im.info.get("dpi") == (72, 72) def test_ifd_offset_exif(self): # Arrange @@ -651,19 +657,16 @@ class TestFileJpeg(PillowTestCase): with Image.open("Tests/images/exif-ifd-offset.jpg") as im: # Act / Assert - self.assertEqual(im._getexif()[306], "2017:03:13 23:03:09") + assert im._getexif()[306] == "2017:03:13 23:03:09" def test_photoshop(self): with Image.open("Tests/images/photoshop-200dpi.jpg") as im: - self.assertEqual( - im.info["photoshop"][0x03ED], - { - "XResolution": 200.0, - "DisplayedUnitsX": 1, - "YResolution": 200.0, - "DisplayedUnitsY": 1, - }, - ) + assert im.info["photoshop"][0x03ED] == { + "XResolution": 200.0, + "DisplayedUnitsX": 1, + "YResolution": 200.0, + "DisplayedUnitsY": 1, + } # Test that the image can still load, even with broken Photoshop data # This image had the APP13 length hexedited to be smaller @@ -672,14 +675,14 @@ class TestFileJpeg(PillowTestCase): # This image does not contain a Photoshop header string with Image.open("Tests/images/app13.jpg") as im: - self.assertNotIn("photoshop", im.info) + assert "photoshop" not in im.info def test_photoshop_malformed_and_multiple(self): with Image.open("Tests/images/app13-multiple.jpg") as im: - self.assertIn("photoshop", im.info) - self.assertEqual(24, len(im.info["photoshop"])) + assert "photoshop" in im.info + assert 24 == len(im.info["photoshop"]) apps_13_lengths = [len(v) for k, v in im.applist if k == "APP13"] - self.assertEqual([65504, 24], apps_13_lengths) + assert [65504, 24] == apps_13_lengths @unittest.skipUnless(is_win32(), "Windows only") @@ -693,9 +696,10 @@ class TestFileCloseW32(PillowTestCase): im = Image.open(tmpfile) fp = im.fp - self.assertFalse(fp.closed) - self.assertRaises(WindowsError, os.remove, tmpfile) + assert not fp.closed + with pytest.raises(WindowsError): + os.remove(tmpfile) im.load() - self.assertTrue(fp.closed) + assert fp.closed # this should not fail, as load should have closed the file. os.remove(tmpfile) diff --git a/Tests/test_file_jpeg2k.py b/Tests/test_file_jpeg2k.py index a1b812429..339b54c46 100644 --- a/Tests/test_file_jpeg2k.py +++ b/Tests/test_file_jpeg2k.py @@ -38,21 +38,22 @@ class TestFileJpeg2k(PillowTestCase): with Image.open("Tests/images/test-card-lossless.jp2") as im: px = im.load() - self.assertEqual(px[0, 0], (0, 0, 0)) - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (640, 480)) - self.assertEqual(im.format, "JPEG2000") - self.assertEqual(im.get_format_mimetype(), "image/jp2") + assert px[0, 0] == (0, 0, 0) + assert im.mode == "RGB" + assert im.size == (640, 480) + assert im.format == "JPEG2000" + assert im.get_format_mimetype() == "image/jp2" def test_jpf(self): with Image.open("Tests/images/balloon.jpf") as im: - self.assertEqual(im.format, "JPEG2000") - self.assertEqual(im.get_format_mimetype(), "image/jpx") + assert im.format == "JPEG2000" + assert im.get_format_mimetype() == "image/jpx" def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(SyntaxError, Jpeg2KImagePlugin.Jpeg2KImageFile, invalid_file) + with pytest.raises(SyntaxError): + Jpeg2KImagePlugin.Jpeg2KImageFile(invalid_file) def test_bytesio(self): with open("Tests/images/test-card-lossless.jp2", "rb") as f: @@ -95,7 +96,7 @@ class TestFileJpeg2k(PillowTestCase): assert_image_equal(im, test_card) def test_tiled_offset_too_small(self): - with self.assertRaises(ValueError): + with pytest.raises(ValueError): self.roundtrip( test_card, tile_size=(128, 128), tile_offset=(0, 0), offset=(128, 32) ) @@ -116,7 +117,7 @@ class TestFileJpeg2k(PillowTestCase): with Image.open("Tests/images/test-card-lossless.jp2") as im: im.reduce = 2 im.load() - self.assertEqual(im.size, (160, 120)) + assert im.size == (160, 120) def test_layers_type(self): outfile = self.tempfile("temp_layers.jp2") @@ -124,9 +125,8 @@ class TestFileJpeg2k(PillowTestCase): test_card.save(outfile, quality_layers=quality_layers) for quality_layers in ["quality_layers", ("100", "50", "10")]: - self.assertRaises( - ValueError, test_card.save, outfile, quality_layers=quality_layers - ) + with pytest.raises(ValueError): + test_card.save(outfile, quality_layers=quality_layers) def test_layers(self): out = BytesIO() @@ -156,17 +156,17 @@ class TestFileJpeg2k(PillowTestCase): jp2.load() # Assert - self.assertEqual(j2k.mode, "RGBA") - self.assertEqual(jp2.mode, "RGBA") + assert j2k.mode == "RGBA" + assert jp2.mode == "RGBA" def test_16bit_monochrome_has_correct_mode(self): with Image.open("Tests/images/16bit.cropped.j2k") as j2k: j2k.load() - self.assertEqual(j2k.mode, "I;16") + assert j2k.mode == "I;16" with Image.open("Tests/images/16bit.cropped.jp2") as jp2: jp2.load() - self.assertEqual(jp2.mode, "I;16") + assert jp2.mode == "I;16" @pytest.mark.xfail(is_big_endian() and on_ci(), reason="Fails on big-endian") def test_16bit_monochrome_jp2_like_tiff(self): @@ -193,7 +193,7 @@ class TestFileJpeg2k(PillowTestCase): def test_unbound_local(self): # prepatch, a malformed jp2 file could cause an UnboundLocalError # exception. - with self.assertRaises(IOError): + with pytest.raises(IOError): Image.open("Tests/images/unbound_variable.jp2") def test_parser_feed(self): @@ -206,4 +206,4 @@ class TestFileJpeg2k(PillowTestCase): p.feed(data) # Assert - self.assertEqual(p.image.size, (640, 480)) + assert p.image.size == (640, 480) diff --git a/Tests/test_file_libtiff.py b/Tests/test_file_libtiff.py index c43bdb7a1..988effee7 100644 --- a/Tests/test_file_libtiff.py +++ b/Tests/test_file_libtiff.py @@ -6,6 +6,7 @@ import os from collections import namedtuple from ctypes import c_float +import pytest from PIL import Image, ImageFilter, TiffImagePlugin, TiffTags from .helper import ( @@ -26,14 +27,14 @@ class LibTiffTestCase(PillowTestCase): def _assert_noerr(self, im): """Helper tests that assert basic sanity about the g4 tiff reading""" # 1 bit - self.assertEqual(im.mode, "1") + assert im.mode == "1" # Does the data actually load im.load() im.getdata() try: - self.assertEqual(im._compression, "group4") + assert im._compression == "group4" except AttributeError: print("No _compression") print(dir(im)) @@ -52,7 +53,7 @@ class TestFileLibTiff(LibTiffTestCase): test_file = "Tests/images/hopper_g4_500.tif" with Image.open(test_file) as im: - self.assertEqual(im.size, (500, 500)) + assert im.size == (500, 500) self._assert_noerr(im) def test_g4_large(self): @@ -66,7 +67,7 @@ class TestFileLibTiff(LibTiffTestCase): test_file = "Tests/images/hopper_g4_500.tif" with open(test_file, "rb") as f: with Image.open(f) as im: - self.assertEqual(im.size, (500, 500)) + assert im.size == (500, 500) self._assert_noerr(im) def test_g4_tiff_bytesio(self): @@ -77,7 +78,7 @@ class TestFileLibTiff(LibTiffTestCase): s.write(f.read()) s.seek(0) with Image.open(s) as im: - self.assertEqual(im.size, (500, 500)) + assert im.size == (500, 500) self._assert_noerr(im) def test_g4_non_disk_file_object(self): @@ -89,7 +90,7 @@ class TestFileLibTiff(LibTiffTestCase): s.seek(0) r = io.BufferedReader(s) with Image.open(r) as im: - self.assertEqual(im.size, (500, 500)) + assert im.size == (500, 500) self._assert_noerr(im) def test_g4_eq_png(self): @@ -111,25 +112,25 @@ class TestFileLibTiff(LibTiffTestCase): with Image.open(test_file) as orig: out = self.tempfile("temp.tif") rot = orig.transpose(Image.ROTATE_90) - self.assertEqual(rot.size, (500, 500)) + assert rot.size == (500, 500) rot.save(out) with Image.open(out) as reread: - self.assertEqual(reread.size, (500, 500)) + assert reread.size == (500, 500) self._assert_noerr(reread) assert_image_equal(reread, rot) - self.assertEqual(reread.info["compression"], "group4") + assert reread.info["compression"] == "group4" - self.assertEqual(reread.info["compression"], orig.info["compression"]) + assert reread.info["compression"] == orig.info["compression"] - self.assertNotEqual(orig.tobytes(), reread.tobytes()) + assert orig.tobytes() != reread.tobytes() def test_adobe_deflate_tiff(self): test_file = "Tests/images/tiff_adobe_deflate.tif" with Image.open(test_file) as im: - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (278, 374)) - self.assertEqual(im.tile[0][:3], ("libtiff", (0, 0, 278, 374), 0)) + assert im.mode == "RGB" + assert im.size == (278, 374) + assert im.tile[0][:3] == ("libtiff", (0, 0, 278, 374), 0) im.load() assert_image_equal_tofile(im, "Tests/images/tiff_adobe_deflate.png") @@ -166,24 +167,21 @@ class TestFileLibTiff(LibTiffTestCase): val = original[tag] if tag.endswith("Resolution"): if legacy_api: - self.assertEqual( - c_float(val[0][0] / val[0][1]).value, - c_float(value[0][0] / value[0][1]).value, - msg="%s didn't roundtrip" % tag, - ) + assert ( + c_float(val[0][0] / val[0][1]).value + == c_float(value[0][0] / value[0][1]).value + ), ("%s didn't roundtrip" % tag) else: - self.assertEqual( - c_float(val).value, - c_float(value).value, - msg="%s didn't roundtrip" % tag, + assert c_float(val).value == c_float(value).value, ( + "%s didn't roundtrip" % tag ) else: - self.assertEqual(val, value, msg="%s didn't roundtrip" % tag) + assert val == value, "%s didn't roundtrip" % tag # https://github.com/python-pillow/Pillow/issues/1561 requested_fields = ["StripByteCounts", "RowsPerStrip", "StripOffsets"] for field in requested_fields: - self.assertIn(field, reloaded, "%s not in metadata" % field) + assert field in reloaded, "%s not in metadata" % field def test_additional_metadata(self): # these should not crash. Seriously dummy data, most of it doesn't make @@ -303,7 +301,7 @@ class TestFileLibTiff(LibTiffTestCase): if libtiff and isinstance(value, bytes): value = value.decode() - self.assertEqual(reloaded_value, value) + assert reloaded_value == value # Test with types ifd = TiffImagePlugin.ImageFileDirectory_v2() @@ -331,7 +329,7 @@ class TestFileLibTiff(LibTiffTestCase): im.save(out, dpi=(72, 72)) TiffImagePlugin.WRITE_LIBTIFF = False with Image.open(out) as reloaded: - self.assertEqual(reloaded.info["dpi"], (72.0, 72.0)) + assert reloaded.info["dpi"] == (72.0, 72.0) def test_g3_compression(self): with Image.open("Tests/images/hopper_g4_500.tif") as i: @@ -339,44 +337,44 @@ class TestFileLibTiff(LibTiffTestCase): i.save(out, compression="group3") with Image.open(out) as reread: - self.assertEqual(reread.info["compression"], "group3") + assert reread.info["compression"] == "group3" assert_image_equal(reread, i) def test_little_endian(self): with Image.open("Tests/images/16bit.deflate.tif") as im: - self.assertEqual(im.getpixel((0, 0)), 480) - self.assertEqual(im.mode, "I;16") + assert im.getpixel((0, 0)) == 480 + assert im.mode == "I;16" b = im.tobytes() # Bytes are in image native order (little endian) - self.assertEqual(b[0], ord(b"\xe0")) - self.assertEqual(b[1], ord(b"\x01")) + assert b[0] == ord(b"\xe0") + assert b[1] == ord(b"\x01") out = self.tempfile("temp.tif") # out = "temp.le.tif" im.save(out) with Image.open(out) as reread: - self.assertEqual(reread.info["compression"], im.info["compression"]) - self.assertEqual(reread.getpixel((0, 0)), 480) + assert reread.info["compression"] == im.info["compression"] + assert reread.getpixel((0, 0)) == 480 # UNDONE - libtiff defaults to writing in native endian, so # on big endian, we'll get back mode = 'I;16B' here. def test_big_endian(self): with Image.open("Tests/images/16bit.MM.deflate.tif") as im: - self.assertEqual(im.getpixel((0, 0)), 480) - self.assertEqual(im.mode, "I;16B") + assert im.getpixel((0, 0)) == 480 + assert im.mode == "I;16B" b = im.tobytes() # Bytes are in image native order (big endian) - self.assertEqual(b[0], ord(b"\x01")) - self.assertEqual(b[1], ord(b"\xe0")) + assert b[0] == ord(b"\x01") + assert b[1] == ord(b"\xe0") out = self.tempfile("temp.tif") im.save(out) with Image.open(out) as reread: - self.assertEqual(reread.info["compression"], im.info["compression"]) - self.assertEqual(reread.getpixel((0, 0)), 480) + assert reread.info["compression"] == im.info["compression"] + assert reread.getpixel((0, 0)) == 480 def test_g4_string_info(self): """Tests String data in info directory""" @@ -388,8 +386,8 @@ class TestFileLibTiff(LibTiffTestCase): orig.save(out) with Image.open(out) as reread: - self.assertEqual("temp.tif", reread.tag_v2[269]) - self.assertEqual("temp.tif", reread.tag[269][0]) + assert "temp.tif" == reread.tag_v2[269] + assert "temp.tif" == reread.tag[269][0] def test_12bit_rawmode(self): """ Are we generating the same interpretation @@ -445,18 +443,22 @@ class TestFileLibTiff(LibTiffTestCase): with Image.open(out) as im3: assert_image_similar(im2, im3, 30) - self.assertGreater(size_raw, size_compressed) - self.assertGreater(size_compressed, size_jpeg) - self.assertGreater(size_jpeg, size_jpeg_30) + assert size_raw > size_compressed + assert size_compressed > size_jpeg + assert size_jpeg > size_jpeg_30 def test_quality(self): im = hopper("RGB") out = self.tempfile("temp.tif") - self.assertRaises(ValueError, im.save, out, compression="tiff_lzw", quality=50) - self.assertRaises(ValueError, im.save, out, compression="jpeg", quality=-1) - self.assertRaises(ValueError, im.save, out, compression="jpeg", quality=101) - self.assertRaises(ValueError, im.save, out, compression="jpeg", quality="good") + with pytest.raises(ValueError): + im.save(out, compression="tiff_lzw", quality=50) + with pytest.raises(ValueError): + im.save(out, compression="jpeg", quality=-1) + with pytest.raises(ValueError): + im.save(out, compression="jpeg", quality=101) + with pytest.raises(ValueError): + im.save(out, compression="jpeg", quality="good") im.save(out, compression="jpeg", quality=0) im.save(out, compression="jpeg", quality=100) @@ -476,9 +478,12 @@ class TestFileLibTiff(LibTiffTestCase): im = hopper("RGB") out = self.tempfile("temp.tif") - self.assertRaises(IOError, im.save, out, compression="tiff_ccitt") - self.assertRaises(IOError, im.save, out, compression="group3") - self.assertRaises(IOError, im.save, out, compression="group4") + with pytest.raises(IOError): + im.save(out, compression="tiff_ccitt") + with pytest.raises(IOError): + im.save(out, compression="group3") + with pytest.raises(IOError): + im.save(out, compression="group4") def test_fp_leak(self): im = Image.open("Tests/images/hopper_g4_500.tif") @@ -486,10 +491,13 @@ class TestFileLibTiff(LibTiffTestCase): os.fstat(fn) im.load() # this should close it. - self.assertRaises(OSError, os.fstat, fn) + with pytest.raises(OSError): + os.fstat(fn) im = None # this should force even more closed. - self.assertRaises(OSError, os.fstat, fn) - self.assertRaises(OSError, os.close, fn) + with pytest.raises(OSError): + os.fstat(fn) + with pytest.raises(OSError): + os.close(fn) def test_multipage(self): # issue #862 @@ -498,19 +506,19 @@ class TestFileLibTiff(LibTiffTestCase): # file is a multipage tiff, 10x10 green, 10x10 red, 20x20 blue im.seek(0) - self.assertEqual(im.size, (10, 10)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 128, 0)) - self.assertTrue(im.tag.next) + assert im.size == (10, 10) + assert im.convert("RGB").getpixel((0, 0)) == (0, 128, 0) + assert im.tag.next im.seek(1) - self.assertEqual(im.size, (10, 10)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (255, 0, 0)) - self.assertTrue(im.tag.next) + assert im.size == (10, 10) + assert im.convert("RGB").getpixel((0, 0)) == (255, 0, 0) + assert im.tag.next im.seek(2) - self.assertFalse(im.tag.next) - self.assertEqual(im.size, (20, 20)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 0, 255)) + assert not im.tag.next + assert im.size == (20, 20) + assert im.convert("RGB").getpixel((0, 0)) == (0, 0, 255) TiffImagePlugin.READ_LIBTIFF = False @@ -519,7 +527,7 @@ class TestFileLibTiff(LibTiffTestCase): TiffImagePlugin.READ_LIBTIFF = True with Image.open("Tests/images/multipage.tiff") as im: frames = im.n_frames - self.assertEqual(frames, 3) + assert frames == 3 for _ in range(frames): im.seek(0) # Should not raise ValueError: I/O operation on closed file @@ -530,9 +538,9 @@ class TestFileLibTiff(LibTiffTestCase): def test__next(self): TiffImagePlugin.READ_LIBTIFF = True with Image.open("Tests/images/hopper.tif") as im: - self.assertFalse(im.tag.next) + assert not im.tag.next im.load() - self.assertFalse(im.tag.next) + assert not im.tag.next def test_4bit(self): # Arrange @@ -545,8 +553,8 @@ class TestFileLibTiff(LibTiffTestCase): TiffImagePlugin.READ_LIBTIFF = False # Assert - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.mode, "L") + assert im.size == (128, 128) + assert im.mode == "L" assert_image_similar(im, original, 7.3) def test_gray_semibyte_per_pixel(self): @@ -573,13 +581,13 @@ class TestFileLibTiff(LibTiffTestCase): original = hopper("L") for epsilon, group in test_files: with Image.open(group[0]) as im: - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.mode, "L") + assert im.size == (128, 128) + assert im.mode == "L" assert_image_similar(im, original, epsilon) for file in group[1:]: with Image.open(file) as im2: - self.assertEqual(im2.size, (128, 128)) - self.assertEqual(im2.mode, "L") + assert im2.size == (128, 128) + assert im2.mode == "L" assert_image_equal(im, im2) def test_save_bytesio(self): @@ -650,29 +658,29 @@ class TestFileLibTiff(LibTiffTestCase): def test_read_icc(self): with Image.open("Tests/images/hopper.iccprofile.tif") as img: icc = img.info.get("icc_profile") - self.assertIsNotNone(icc) + assert icc is not None TiffImagePlugin.READ_LIBTIFF = True with Image.open("Tests/images/hopper.iccprofile.tif") as img: icc_libtiff = img.info.get("icc_profile") - self.assertIsNotNone(icc_libtiff) + assert icc_libtiff is not None TiffImagePlugin.READ_LIBTIFF = False - self.assertEqual(icc, icc_libtiff) + assert icc == icc_libtiff def test_multipage_compression(self): with Image.open("Tests/images/compression.tif") as im: im.seek(0) - self.assertEqual(im._compression, "tiff_ccitt") - self.assertEqual(im.size, (10, 10)) + assert im._compression == "tiff_ccitt" + assert im.size == (10, 10) im.seek(1) - self.assertEqual(im._compression, "packbits") - self.assertEqual(im.size, (10, 10)) + assert im._compression == "packbits" + assert im.size == (10, 10) im.load() im.seek(0) - self.assertEqual(im._compression, "tiff_ccitt") - self.assertEqual(im.size, (10, 10)) + assert im._compression == "tiff_ccitt" + assert im.size == (10, 10) im.load() def test_save_tiff_with_jpegtables(self): @@ -689,38 +697,27 @@ class TestFileLibTiff(LibTiffTestCase): def test_16bit_RGB_tiff(self): with Image.open("Tests/images/tiff_16bit_RGB.tiff") as im: - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (100, 40)) - self.assertEqual( - im.tile, - [ - ( - "libtiff", - (0, 0, 100, 40), - 0, - ("RGB;16N", "tiff_adobe_deflate", False, 8), - ) - ], - ) + assert im.mode == "RGB" + assert im.size == (100, 40) + assert im.tile, [ + ( + "libtiff", + (0, 0, 100, 40), + 0, + ("RGB;16N", "tiff_adobe_deflate", False, 8), + ) + ] im.load() assert_image_equal_tofile(im, "Tests/images/tiff_16bit_RGB_target.png") def test_16bit_RGBa_tiff(self): with Image.open("Tests/images/tiff_16bit_RGBa.tiff") as im: - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (100, 40)) - self.assertEqual( - im.tile, - [ - ( - "libtiff", - (0, 0, 100, 40), - 0, - ("RGBa;16N", "tiff_lzw", False, 38236), - ) - ], - ) + assert im.mode == "RGBA" + assert im.size == (100, 40) + assert im.tile, [ + ("libtiff", (0, 0, 100, 40), 0, ("RGBa;16N", "tiff_lzw", False, 38236),) + ] im.load() assert_image_equal_tofile(im, "Tests/images/tiff_16bit_RGBa_target.png") @@ -730,12 +727,11 @@ class TestFileLibTiff(LibTiffTestCase): # Read TIFF JPEG images from GIMP [@PIL168] filename = "Tests/images/pil168.tif" with Image.open(filename) as im: - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (256, 256)) - self.assertEqual( - im.tile, - [("libtiff", (0, 0, 256, 256), 0, ("RGB", "jpeg", False, 5122))], - ) + assert im.mode == "RGB" + assert im.size == (256, 256) + assert im.tile == [ + ("libtiff", (0, 0, 256, 256), 0, ("RGB", "jpeg", False, 5122)) + ] im.load() assert_image_equal_tofile(im, "Tests/images/pil168.png") @@ -743,15 +739,15 @@ class TestFileLibTiff(LibTiffTestCase): def test_sampleformat(self): # https://github.com/python-pillow/Pillow/issues/1466 with Image.open("Tests/images/copyleft.tiff") as im: - self.assertEqual(im.mode, "RGB") + assert im.mode == "RGB" assert_image_equal_tofile(im, "Tests/images/copyleft.png", mode="RGB") def test_lzw(self): with Image.open("Tests/images/hopper_lzw.tif") as im: - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "TIFF") + assert im.mode == "RGB" + assert im.size == (128, 128) + assert im.format == "TIFF" im2 = hopper() assert_image_similar(im, im2, 5) @@ -800,7 +796,7 @@ class TestFileLibTiff(LibTiffTestCase): infile = "Tests/images/no_rows_per_strip.tif" with Image.open(infile) as im: im.load() - self.assertEqual(im.size, (950, 975)) + assert im.size == (950, 975) def test_orientation(self): with Image.open("Tests/images/g4_orientation_1.tif") as base_im: @@ -834,9 +830,9 @@ class TestFileLibTiff(LibTiffTestCase): def test_realloc_overflow(self): TiffImagePlugin.READ_LIBTIFF = True with Image.open("Tests/images/tiff_overflow_rows_per_strip.tif") as im: - with self.assertRaises(IOError) as e: + with pytest.raises(IOError) as e: im.load() # Assert that the error code is IMAGING_CODEC_MEMORY - self.assertEqual(str(e.exception), "-9") + assert str(e.value) == "-9" TiffImagePlugin.READ_LIBTIFF = False diff --git a/Tests/test_file_libtiff_small.py b/Tests/test_file_libtiff_small.py index a4e74896f..5bac8ebf7 100644 --- a/Tests/test_file_libtiff_small.py +++ b/Tests/test_file_libtiff_small.py @@ -21,7 +21,7 @@ class TestFileLibTiffSmall(LibTiffTestCase): test_file = "Tests/images/hopper_g4.tif" with open(test_file, "rb") as f: with Image.open(f) as im: - self.assertEqual(im.size, (128, 128)) + assert im.size == (128, 128) self._assert_noerr(im) def test_g4_hopper_bytesio(self): @@ -32,7 +32,7 @@ class TestFileLibTiffSmall(LibTiffTestCase): s.write(f.read()) s.seek(0) with Image.open(s) as im: - self.assertEqual(im.size, (128, 128)) + assert im.size == (128, 128) self._assert_noerr(im) def test_g4_hopper(self): @@ -40,5 +40,5 @@ class TestFileLibTiffSmall(LibTiffTestCase): test_file = "Tests/images/hopper_g4.tif" with Image.open(test_file) as im: - self.assertEqual(im.size, (128, 128)) + assert im.size == (128, 128) self._assert_noerr(im) diff --git a/Tests/test_file_msp.py b/Tests/test_file_msp.py index 4b355441a..84fd4a0e2 100644 --- a/Tests/test_file_msp.py +++ b/Tests/test_file_msp.py @@ -1,6 +1,7 @@ import os import unittest +import pytest from PIL import Image, MspImagePlugin from .helper import PillowTestCase, assert_image_equal, hopper @@ -18,14 +19,15 @@ class TestFileMsp(PillowTestCase): with Image.open(test_file) as im: im.load() - self.assertEqual(im.mode, "1") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "MSP") + assert im.mode == "1" + assert im.size == (128, 128) + assert im.format == "MSP" def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(SyntaxError, MspImagePlugin.MspImageFile, invalid_file) + with pytest.raises(SyntaxError): + MspImagePlugin.MspImageFile(invalid_file) def test_bad_checksum(self): # Arrange @@ -33,7 +35,8 @@ class TestFileMsp(PillowTestCase): bad_checksum = "Tests/images/hopper_bad_checksum.msp" # Act / Assert - self.assertRaises(SyntaxError, MspImagePlugin.MspImageFile, bad_checksum) + with pytest.raises(SyntaxError): + MspImagePlugin.MspImageFile(bad_checksum) def test_open_windows_v1(self): # Arrange @@ -42,7 +45,7 @@ class TestFileMsp(PillowTestCase): # Assert assert_image_equal(im, hopper("1")) - self.assertIsInstance(im, MspImagePlugin.MspImageFile) + assert isinstance(im, MspImagePlugin.MspImageFile) def _assert_file_image_equal(self, source_path, target_path): with Image.open(source_path) as im: @@ -76,4 +79,5 @@ class TestFileMsp(PillowTestCase): filename = self.tempfile("temp.msp") # Act/Assert - self.assertRaises(IOError, im.save, filename) + with pytest.raises(IOError): + im.save(filename) diff --git a/Tests/test_file_palm.py b/Tests/test_file_palm.py index 0faa4c705..909272532 100644 --- a/Tests/test_file_palm.py +++ b/Tests/test_file_palm.py @@ -1,5 +1,7 @@ import os.path +import pytest + from .helper import ( PillowTestCase, assert_image_equal, @@ -21,8 +23,8 @@ class TestFilePalm(PillowTestCase): im.save(outfile) # Assert - self.assertTrue(os.path.isfile(outfile)) - self.assertGreater(os.path.getsize(outfile), 0) + assert os.path.isfile(outfile) + assert os.path.getsize(outfile) > 0 def roundtrip(self, mode): if not self._roundtrip: @@ -57,11 +59,13 @@ class TestFilePalm(PillowTestCase): mode = "L" # Act / Assert - self.assertRaises(IOError, self.helper_save_as_palm, mode) + with pytest.raises(IOError): + self.helper_save_as_palm(mode) def test_rgb_ioerror(self): # Arrange mode = "RGB" # Act / Assert - self.assertRaises(IOError, self.helper_save_as_palm, mode) + with pytest.raises(IOError): + self.helper_save_as_palm(mode) diff --git a/Tests/test_file_pcx.py b/Tests/test_file_pcx.py index 443bef8f5..3ae27213c 100644 --- a/Tests/test_file_pcx.py +++ b/Tests/test_file_pcx.py @@ -1,3 +1,4 @@ +import pytest from PIL import Image, ImageFile, PcxImagePlugin from .helper import PillowTestCase, assert_image_equal, hopper @@ -8,10 +9,10 @@ class TestFilePcx(PillowTestCase): f = self.tempfile("temp.pcx") im.save(f) with Image.open(f) as im2: - self.assertEqual(im2.mode, im.mode) - self.assertEqual(im2.size, im.size) - self.assertEqual(im2.format, "PCX") - self.assertEqual(im2.get_format_mimetype(), "image/x-pcx") + assert im2.mode == im.mode + assert im2.size == im.size + assert im2.format == "PCX" + assert im2.get_format_mimetype() == "image/x-pcx" assert_image_equal(im2, im) def test_sanity(self): @@ -21,12 +22,14 @@ class TestFilePcx(PillowTestCase): # Test an unsupported mode f = self.tempfile("temp.pcx") im = hopper("RGBA") - self.assertRaises(ValueError, im.save, f) + with pytest.raises(ValueError): + im.save(f) def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(SyntaxError, PcxImagePlugin.PcxImageFile, invalid_file) + with pytest.raises(SyntaxError): + PcxImagePlugin.PcxImageFile(invalid_file) def test_odd(self): # see issue #523, odd sized images should have a stride that's even. @@ -42,11 +45,11 @@ class TestFilePcx(PillowTestCase): test_file = "Tests/images/pil184.pcx" with Image.open(test_file) as im: - self.assertEqual(im.size, (447, 144)) - self.assertEqual(im.tile[0][1], (0, 0, 447, 144)) + assert im.size == (447, 144) + assert im.tile[0][1] == (0, 0, 447, 144) # Make sure all pixels are either 0 or 255. - self.assertEqual(im.histogram()[0] + im.histogram()[255], 447 * 144) + assert im.histogram()[0] + im.histogram()[255] == 447 * 144 def test_1px_width(self): im = Image.new("L", (1, 256)) diff --git a/Tests/test_file_pdf.py b/Tests/test_file_pdf.py index 9b8b789b9..99ef39147 100644 --- a/Tests/test_file_pdf.py +++ b/Tests/test_file_pdf.py @@ -4,6 +4,7 @@ import os.path import tempfile import time +import pytest from PIL import Image, PdfParser from .helper import PillowTestCase, hopper @@ -19,20 +20,20 @@ class TestFilePdf(PillowTestCase): im.save(outfile, **kwargs) # Assert - self.assertTrue(os.path.isfile(outfile)) - self.assertGreater(os.path.getsize(outfile), 0) + assert os.path.isfile(outfile) + assert os.path.getsize(outfile) > 0 with PdfParser.PdfParser(outfile) as pdf: if kwargs.get("append_images", False) or kwargs.get("append", False): - self.assertGreater(len(pdf.pages), 1) + assert len(pdf.pages) > 1 else: - self.assertGreater(len(pdf.pages), 0) + assert len(pdf.pages) > 0 with open(outfile, "rb") as fp: contents = fp.read() size = tuple( int(d) for d in contents.split(b"/MediaBox [ 0 0 ")[1].split(b"]")[0].split() ) - self.assertEqual(im.size, size) + assert im.size == size return outfile @@ -75,7 +76,8 @@ class TestFilePdf(PillowTestCase): im = hopper("LA") outfile = self.tempfile("temp_LA.pdf") - self.assertRaises(ValueError, im.save, outfile) + with pytest.raises(ValueError): + im.save(outfile) def test_save_all(self): # Single frame image @@ -87,15 +89,15 @@ class TestFilePdf(PillowTestCase): outfile = self.tempfile("temp.pdf") im.save(outfile, save_all=True) - self.assertTrue(os.path.isfile(outfile)) - self.assertGreater(os.path.getsize(outfile), 0) + assert os.path.isfile(outfile) + assert os.path.getsize(outfile) > 0 # Append images ims = [hopper()] im.copy().save(outfile, save_all=True, append_images=ims) - self.assertTrue(os.path.isfile(outfile)) - self.assertGreater(os.path.getsize(outfile), 0) + assert os.path.isfile(outfile) + assert os.path.getsize(outfile) > 0 # Test appending using a generator def imGenerator(ims): @@ -103,15 +105,15 @@ class TestFilePdf(PillowTestCase): im.save(outfile, save_all=True, append_images=imGenerator(ims)) - self.assertTrue(os.path.isfile(outfile)) - self.assertGreater(os.path.getsize(outfile), 0) + assert os.path.isfile(outfile) + assert os.path.getsize(outfile) > 0 # Append JPEG images with Image.open("Tests/images/flower.jpg") as jpeg: jpeg.save(outfile, save_all=True, append_images=[jpeg.copy()]) - self.assertTrue(os.path.isfile(outfile)) - self.assertGreater(os.path.getsize(outfile), 0) + assert os.path.isfile(outfile) + assert os.path.getsize(outfile) > 0 def test_multiframe_normal_save(self): # Test saving a multiframe image without save_all @@ -120,69 +122,67 @@ class TestFilePdf(PillowTestCase): outfile = self.tempfile("temp.pdf") im.save(outfile) - self.assertTrue(os.path.isfile(outfile)) - self.assertGreater(os.path.getsize(outfile), 0) + assert os.path.isfile(outfile) + assert os.path.getsize(outfile) > 0 def test_pdf_open(self): # fail on a buffer full of null bytes - self.assertRaises( - PdfParser.PdfFormatError, PdfParser.PdfParser, buf=bytearray(65536) - ) + with pytest.raises(PdfParser.PdfFormatError): + PdfParser.PdfParser(buf=bytearray(65536)) # make an empty PDF object with PdfParser.PdfParser() as empty_pdf: - self.assertEqual(len(empty_pdf.pages), 0) - self.assertEqual(len(empty_pdf.info), 0) - self.assertFalse(empty_pdf.should_close_buf) - self.assertFalse(empty_pdf.should_close_file) + assert len(empty_pdf.pages) == 0 + assert len(empty_pdf.info) == 0 + assert not empty_pdf.should_close_buf + assert not empty_pdf.should_close_file # make a PDF file pdf_filename = self.helper_save_as_pdf("RGB") # open the PDF file with PdfParser.PdfParser(filename=pdf_filename) as hopper_pdf: - self.assertEqual(len(hopper_pdf.pages), 1) - self.assertTrue(hopper_pdf.should_close_buf) - self.assertTrue(hopper_pdf.should_close_file) + assert len(hopper_pdf.pages) == 1 + assert hopper_pdf.should_close_buf + assert hopper_pdf.should_close_file # read a PDF file from a buffer with a non-zero offset with open(pdf_filename, "rb") as f: content = b"xyzzy" + f.read() with PdfParser.PdfParser(buf=content, start_offset=5) as hopper_pdf: - self.assertEqual(len(hopper_pdf.pages), 1) - self.assertFalse(hopper_pdf.should_close_buf) - self.assertFalse(hopper_pdf.should_close_file) + assert len(hopper_pdf.pages) == 1 + assert not hopper_pdf.should_close_buf + assert not hopper_pdf.should_close_file # read a PDF file from an already open file with open(pdf_filename, "rb") as f: with PdfParser.PdfParser(f=f) as hopper_pdf: - self.assertEqual(len(hopper_pdf.pages), 1) - self.assertTrue(hopper_pdf.should_close_buf) - self.assertFalse(hopper_pdf.should_close_file) + assert len(hopper_pdf.pages) == 1 + assert hopper_pdf.should_close_buf + assert not hopper_pdf.should_close_file def test_pdf_append_fails_on_nonexistent_file(self): im = hopper("RGB") with tempfile.TemporaryDirectory() as temp_dir: - self.assertRaises( - IOError, im.save, os.path.join(temp_dir, "nonexistent.pdf"), append=True - ) + with pytest.raises(IOError): + im.save(os.path.join(temp_dir, "nonexistent.pdf"), append=True) def check_pdf_pages_consistency(self, pdf): pages_info = pdf.read_indirect(pdf.pages_ref) - self.assertNotIn(b"Parent", pages_info) - self.assertIn(b"Kids", pages_info) + assert b"Parent" not in pages_info + assert b"Kids" in pages_info kids_not_used = pages_info[b"Kids"] for page_ref in pdf.pages: while True: if page_ref in kids_not_used: kids_not_used.remove(page_ref) page_info = pdf.read_indirect(page_ref) - self.assertIn(b"Parent", page_info) + assert b"Parent" in page_info page_ref = page_info[b"Parent"] if page_ref == pdf.pages_ref: break - self.assertEqual(pdf.pages_ref, page_info[b"Parent"]) - self.assertEqual(kids_not_used, []) + assert pdf.pages_ref == page_info[b"Parent"] + assert kids_not_used == [] def test_pdf_append(self): # make a PDF file @@ -190,14 +190,12 @@ class TestFilePdf(PillowTestCase): # open it, check pages and info with PdfParser.PdfParser(pdf_filename, mode="r+b") as pdf: - self.assertEqual(len(pdf.pages), 1) - self.assertEqual(len(pdf.info), 4) - self.assertEqual( - pdf.info.Title, os.path.splitext(os.path.basename(pdf_filename))[0] - ) - self.assertEqual(pdf.info.Producer, "PdfParser") - self.assertIn(b"CreationDate", pdf.info) - self.assertIn(b"ModDate", pdf.info) + assert len(pdf.pages) == 1 + assert len(pdf.info) == 4 + assert pdf.info.Title == os.path.splitext(os.path.basename(pdf_filename))[0] + assert pdf.info.Producer == "PdfParser" + assert b"CreationDate" in pdf.info + assert b"ModDate" in pdf.info self.check_pdf_pages_consistency(pdf) # append some info @@ -211,11 +209,11 @@ class TestFilePdf(PillowTestCase): # open it again, check pages and info again with PdfParser.PdfParser(pdf_filename) as pdf: - self.assertEqual(len(pdf.pages), 1) - self.assertEqual(len(pdf.info), 8) - self.assertEqual(pdf.info.Title, "abc") - self.assertIn(b"CreationDate", pdf.info) - self.assertIn(b"ModDate", pdf.info) + assert len(pdf.pages) == 1 + assert len(pdf.info) == 8 + assert pdf.info.Title == "abc" + assert b"CreationDate" in pdf.info + assert b"ModDate" in pdf.info self.check_pdf_pages_consistency(pdf) # append two images @@ -225,15 +223,15 @@ class TestFilePdf(PillowTestCase): # open the PDF again, check pages and info again with PdfParser.PdfParser(pdf_filename) as pdf: - self.assertEqual(len(pdf.pages), 3) - self.assertEqual(len(pdf.info), 8) - self.assertEqual(PdfParser.decode_text(pdf.info[b"Title"]), "abc") - self.assertEqual(pdf.info.Title, "abc") - self.assertEqual(pdf.info.Producer, "PdfParser") - self.assertEqual(pdf.info.Keywords, "qw)e\\r(ty") - self.assertEqual(pdf.info.Subject, "ghi\uABCD") - self.assertIn(b"CreationDate", pdf.info) - self.assertIn(b"ModDate", pdf.info) + assert len(pdf.pages) == 3 + assert len(pdf.info) == 8 + assert PdfParser.decode_text(pdf.info[b"Title"]) == "abc" + assert pdf.info.Title == "abc" + assert pdf.info.Producer == "PdfParser" + assert pdf.info.Keywords == "qw)e\\r(ty" + assert pdf.info.Subject == "ghi\uABCD" + assert b"CreationDate" in pdf.info + assert b"ModDate" in pdf.info self.check_pdf_pages_consistency(pdf) def test_pdf_info(self): @@ -252,15 +250,15 @@ class TestFilePdf(PillowTestCase): # open it, check pages and info with PdfParser.PdfParser(pdf_filename) as pdf: - self.assertEqual(len(pdf.info), 8) - self.assertEqual(pdf.info.Title, "title") - self.assertEqual(pdf.info.Author, "author") - self.assertEqual(pdf.info.Subject, "subject") - self.assertEqual(pdf.info.Keywords, "keywords") - self.assertEqual(pdf.info.Creator, "creator") - self.assertEqual(pdf.info.Producer, "producer") - self.assertEqual(pdf.info.CreationDate, time.strptime("2000", "%Y")) - self.assertEqual(pdf.info.ModDate, time.strptime("2001", "%Y")) + assert len(pdf.info) == 8 + assert pdf.info.Title == "title" + assert pdf.info.Author == "author" + assert pdf.info.Subject == "subject" + assert pdf.info.Keywords == "keywords" + assert pdf.info.Creator == "creator" + assert pdf.info.Producer == "producer" + assert pdf.info.CreationDate == time.strptime("2000", "%Y") + assert pdf.info.ModDate == time.strptime("2001", "%Y") self.check_pdf_pages_consistency(pdf) def test_pdf_append_to_bytesio(self): @@ -268,8 +266,8 @@ class TestFilePdf(PillowTestCase): f = io.BytesIO() im.save(f, format="PDF") initial_size = len(f.getvalue()) - self.assertGreater(initial_size, 0) + assert initial_size > 0 im = hopper("P") f = io.BytesIO(f.getvalue()) im.save(f, format="PDF", append=True) - self.assertGreater(len(f.getvalue()), initial_size) + assert len(f.getvalue()) > initial_size diff --git a/Tests/test_file_png.py b/Tests/test_file_png.py index b319bc41e..c434d836c 100644 --- a/Tests/test_file_png.py +++ b/Tests/test_file_png.py @@ -83,10 +83,10 @@ class TestFilePng(PillowTestCase): with Image.open(test_file) as im: im.load() - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "PNG") - self.assertEqual(im.get_format_mimetype(), "image/png") + assert im.mode == "RGB" + assert im.size == (128, 128) + assert im.format == "PNG" + assert im.get_format_mimetype() == "image/png" for mode in ["1", "L", "P", "RGB", "I", "I;16"]: im = hopper(mode) @@ -99,112 +99,114 @@ class TestFilePng(PillowTestCase): def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(SyntaxError, PngImagePlugin.PngImageFile, invalid_file) + with pytest.raises(SyntaxError): + PngImagePlugin.PngImageFile(invalid_file) def test_broken(self): # Check reading of totally broken files. In this case, the test # file was checked into Subversion as a text file. test_file = "Tests/images/broken.png" - self.assertRaises(IOError, Image.open, test_file) + with pytest.raises(IOError): + Image.open(test_file) def test_bad_text(self): # Make sure PIL can read malformed tEXt chunks (@PIL152) im = load(HEAD + chunk(b"tEXt") + TAIL) - self.assertEqual(im.info, {}) + assert im.info == {} im = load(HEAD + chunk(b"tEXt", b"spam") + TAIL) - self.assertEqual(im.info, {"spam": ""}) + assert im.info == {"spam": ""} im = load(HEAD + chunk(b"tEXt", b"spam\0") + TAIL) - self.assertEqual(im.info, {"spam": ""}) + assert im.info == {"spam": ""} im = load(HEAD + chunk(b"tEXt", b"spam\0egg") + TAIL) - self.assertEqual(im.info, {"spam": "egg"}) + assert im.info == {"spam": "egg"} im = load(HEAD + chunk(b"tEXt", b"spam\0egg\0") + TAIL) - self.assertEqual(im.info, {"spam": "egg\x00"}) + assert im.info == {"spam": "egg\x00"} def test_bad_ztxt(self): # Test reading malformed zTXt chunks (python-pillow/Pillow#318) im = load(HEAD + chunk(b"zTXt") + TAIL) - self.assertEqual(im.info, {}) + assert im.info == {} im = load(HEAD + chunk(b"zTXt", b"spam") + TAIL) - self.assertEqual(im.info, {"spam": ""}) + assert im.info == {"spam": ""} im = load(HEAD + chunk(b"zTXt", b"spam\0") + TAIL) - self.assertEqual(im.info, {"spam": ""}) + assert im.info == {"spam": ""} im = load(HEAD + chunk(b"zTXt", b"spam\0\0") + TAIL) - self.assertEqual(im.info, {"spam": ""}) + assert im.info == {"spam": ""} im = load(HEAD + chunk(b"zTXt", b"spam\0\0" + zlib.compress(b"egg")[:1]) + TAIL) - self.assertEqual(im.info, {"spam": ""}) + assert im.info == {"spam": ""} im = load(HEAD + chunk(b"zTXt", b"spam\0\0" + zlib.compress(b"egg")) + TAIL) - self.assertEqual(im.info, {"spam": "egg"}) + assert im.info == {"spam": "egg"} def test_bad_itxt(self): im = load(HEAD + chunk(b"iTXt") + TAIL) - self.assertEqual(im.info, {}) + assert im.info == {} im = load(HEAD + chunk(b"iTXt", b"spam") + TAIL) - self.assertEqual(im.info, {}) + assert im.info == {} im = load(HEAD + chunk(b"iTXt", b"spam\0") + TAIL) - self.assertEqual(im.info, {}) + assert im.info == {} im = load(HEAD + chunk(b"iTXt", b"spam\0\x02") + TAIL) - self.assertEqual(im.info, {}) + assert im.info == {} im = load(HEAD + chunk(b"iTXt", b"spam\0\0\0foo\0") + TAIL) - self.assertEqual(im.info, {}) + assert im.info == {} im = load(HEAD + chunk(b"iTXt", b"spam\0\0\0en\0Spam\0egg") + TAIL) - self.assertEqual(im.info, {"spam": "egg"}) - self.assertEqual(im.info["spam"].lang, "en") - self.assertEqual(im.info["spam"].tkey, "Spam") + assert im.info == {"spam": "egg"} + assert im.info["spam"].lang == "en" + assert im.info["spam"].tkey == "Spam" im = load( HEAD + chunk(b"iTXt", b"spam\0\1\0en\0Spam\0" + zlib.compress(b"egg")[:1]) + TAIL ) - self.assertEqual(im.info, {"spam": ""}) + assert im.info == {"spam": ""} im = load( HEAD + chunk(b"iTXt", b"spam\0\1\1en\0Spam\0" + zlib.compress(b"egg")) + TAIL ) - self.assertEqual(im.info, {}) + assert im.info == {} im = load( HEAD + chunk(b"iTXt", b"spam\0\1\0en\0Spam\0" + zlib.compress(b"egg")) + TAIL ) - self.assertEqual(im.info, {"spam": "egg"}) - self.assertEqual(im.info["spam"].lang, "en") - self.assertEqual(im.info["spam"].tkey, "Spam") + assert im.info == {"spam": "egg"} + assert im.info["spam"].lang == "en" + assert im.info["spam"].tkey == "Spam" def test_interlace(self): test_file = "Tests/images/pil123p.png" with Image.open(test_file) as im: assert_image(im, "P", (162, 150)) - self.assertTrue(im.info.get("interlace")) + assert im.info.get("interlace") im.load() test_file = "Tests/images/pil123rgba.png" with Image.open(test_file) as im: assert_image(im, "RGBA", (162, 150)) - self.assertTrue(im.info.get("interlace")) + assert im.info.get("interlace") im.load() @@ -216,69 +218,69 @@ class TestFilePng(PillowTestCase): assert_image(im, "RGBA", (162, 150)) # image has 124 unique alpha values - self.assertEqual(len(im.getchannel("A").getcolors()), 124) + assert len(im.getchannel("A").getcolors()) == 124 def test_load_transparent_rgb(self): test_file = "Tests/images/rgb_trns.png" with Image.open(test_file) as im: - self.assertEqual(im.info["transparency"], (0, 255, 52)) + assert im.info["transparency"] == (0, 255, 52) assert_image(im, "RGB", (64, 64)) im = im.convert("RGBA") assert_image(im, "RGBA", (64, 64)) # image has 876 transparent pixels - self.assertEqual(im.getchannel("A").getcolors()[0][0], 876) + assert im.getchannel("A").getcolors()[0][0] == 876 def test_save_p_transparent_palette(self): in_file = "Tests/images/pil123p.png" with Image.open(in_file) as im: # 'transparency' contains a byte string with the opacity for # each palette entry - self.assertEqual(len(im.info["transparency"]), 256) + assert len(im.info["transparency"]) == 256 test_file = self.tempfile("temp.png") im.save(test_file) # check if saved image contains same transparency with Image.open(test_file) as im: - self.assertEqual(len(im.info["transparency"]), 256) + assert len(im.info["transparency"]) == 256 assert_image(im, "P", (162, 150)) im = im.convert("RGBA") assert_image(im, "RGBA", (162, 150)) # image has 124 unique alpha values - self.assertEqual(len(im.getchannel("A").getcolors()), 124) + assert len(im.getchannel("A").getcolors()) == 124 def test_save_p_single_transparency(self): in_file = "Tests/images/p_trns_single.png" with Image.open(in_file) as im: # pixel value 164 is full transparent - self.assertEqual(im.info["transparency"], 164) - self.assertEqual(im.getpixel((31, 31)), 164) + assert im.info["transparency"] == 164 + assert im.getpixel((31, 31)) == 164 test_file = self.tempfile("temp.png") im.save(test_file) # check if saved image contains same transparency with Image.open(test_file) as im: - self.assertEqual(im.info["transparency"], 164) - self.assertEqual(im.getpixel((31, 31)), 164) + assert im.info["transparency"] == 164 + assert im.getpixel((31, 31)) == 164 assert_image(im, "P", (64, 64)) im = im.convert("RGBA") assert_image(im, "RGBA", (64, 64)) - self.assertEqual(im.getpixel((31, 31)), (0, 255, 52, 0)) + assert im.getpixel((31, 31)) == (0, 255, 52, 0) # image has 876 transparent pixels - self.assertEqual(im.getchannel("A").getcolors()[0][0], 876) + assert im.getchannel("A").getcolors()[0][0] == 876 def test_save_p_transparent_black(self): # check if solid black image with full transparency # is supported (check for #1838) im = Image.new("RGBA", (10, 10), (0, 0, 0, 0)) - self.assertEqual(im.getcolors(), [(100, (0, 0, 0, 0))]) + assert im.getcolors() == [(100, (0, 0, 0, 0))] im = im.convert("P") test_file = self.tempfile("temp.png") @@ -286,34 +288,32 @@ class TestFilePng(PillowTestCase): # check if saved image contains same transparency with Image.open(test_file) as im: - self.assertEqual(len(im.info["transparency"]), 256) + assert len(im.info["transparency"]) == 256 assert_image(im, "P", (10, 10)) im = im.convert("RGBA") assert_image(im, "RGBA", (10, 10)) - self.assertEqual(im.getcolors(), [(100, (0, 0, 0, 0))]) + assert im.getcolors() == [(100, (0, 0, 0, 0))] def test_save_greyscale_transparency(self): for mode, num_transparent in {"1": 1994, "L": 559, "I": 559}.items(): in_file = "Tests/images/" + mode.lower() + "_trns.png" with Image.open(in_file) as im: - self.assertEqual(im.mode, mode) - self.assertEqual(im.info["transparency"], 255) + assert im.mode == mode + assert im.info["transparency"] == 255 im_rgba = im.convert("RGBA") - self.assertEqual(im_rgba.getchannel("A").getcolors()[0][0], num_transparent) + assert im_rgba.getchannel("A").getcolors()[0][0] == num_transparent test_file = self.tempfile("temp.png") im.save(test_file) with Image.open(test_file) as test_im: - self.assertEqual(test_im.mode, mode) - self.assertEqual(test_im.info["transparency"], 255) + assert test_im.mode == mode + assert test_im.info["transparency"] == 255 assert_image_equal(im, test_im) test_im_rgba = test_im.convert("RGBA") - self.assertEqual( - test_im_rgba.getchannel("A").getcolors()[0][0], num_transparent - ) + assert test_im_rgba.getchannel("A").getcolors()[0][0] == num_transparent def test_save_rgb_single_transparency(self): in_file = "Tests/images/caption_6_33_22.png" @@ -330,7 +330,8 @@ class TestFilePng(PillowTestCase): with Image.open(TEST_PNG_FILE) as im: im.load() - self.assertRaises(RuntimeError, im.verify) + with pytest.raises(RuntimeError): + im.verify() def test_verify_struct_error(self): # Check open/load/verify exception (#1755) @@ -344,8 +345,9 @@ class TestFilePng(PillowTestCase): test_file = f.read()[:offset] with Image.open(BytesIO(test_file)) as im: - self.assertIsNotNone(im.fp) - self.assertRaises((IOError, SyntaxError), im.verify) + assert im.fp is not None + with pytest.raises((IOError, SyntaxError)): + im.verify() def test_verify_ignores_crc_error(self): # check ignores crc errors in ancillary chunks @@ -354,12 +356,13 @@ class TestFilePng(PillowTestCase): broken_crc_chunk_data = chunk_data[:-1] + b"q" # break CRC image_data = HEAD + broken_crc_chunk_data + TAIL - self.assertRaises(SyntaxError, PngImagePlugin.PngImageFile, BytesIO(image_data)) + with pytest.raises(SyntaxError): + PngImagePlugin.PngImageFile(BytesIO(image_data)) ImageFile.LOAD_TRUNCATED_IMAGES = True try: im = load(image_data) - self.assertIsNotNone(im) + assert im is not None finally: ImageFile.LOAD_TRUNCATED_IMAGES = False @@ -370,9 +373,8 @@ class TestFilePng(PillowTestCase): ImageFile.LOAD_TRUNCATED_IMAGES = True try: - self.assertRaises( - SyntaxError, PngImagePlugin.PngImageFile, BytesIO(image_data) - ) + with pytest.raises(SyntaxError): + PngImagePlugin.PngImageFile(BytesIO(image_data)) finally: ImageFile.LOAD_TRUNCATED_IMAGES = False @@ -381,24 +383,24 @@ class TestFilePng(PillowTestCase): with Image.open(TEST_PNG_FILE) as im: im = roundtrip(im, dpi=(100, 100)) - self.assertEqual(im.info["dpi"], (100, 100)) + assert im.info["dpi"] == (100, 100) def test_load_dpi_rounding(self): # Round up with Image.open(TEST_PNG_FILE) as im: - self.assertEqual(im.info["dpi"], (96, 96)) + assert im.info["dpi"] == (96, 96) # Round down with Image.open("Tests/images/icc_profile_none.png") as im: - self.assertEqual(im.info["dpi"], (72, 72)) + assert im.info["dpi"] == (72, 72) def test_save_dpi_rounding(self): with Image.open(TEST_PNG_FILE) as im: im = roundtrip(im, dpi=(72.2, 72.2)) - self.assertEqual(im.info["dpi"], (72, 72)) + assert im.info["dpi"] == (72, 72) im = roundtrip(im, dpi=(72.8, 72.8)) - self.assertEqual(im.info["dpi"], (73, 73)) + assert im.info["dpi"] == (73, 73) def test_roundtrip_text(self): # Check text roundtripping @@ -409,8 +411,8 @@ class TestFilePng(PillowTestCase): info.add_text("ZIP", "VALUE", zip=True) im = roundtrip(im, pnginfo=info) - self.assertEqual(im.info, {"TXT": "VALUE", "ZIP": "VALUE"}) - self.assertEqual(im.text, {"TXT": "VALUE", "ZIP": "VALUE"}) + assert im.info == {"TXT": "VALUE", "ZIP": "VALUE"} + assert im.text == {"TXT": "VALUE", "ZIP": "VALUE"} def test_roundtrip_itxt(self): # Check iTXt roundtripping @@ -421,12 +423,12 @@ class TestFilePng(PillowTestCase): info.add_text("eggs", PngImagePlugin.iTXt("Spam", "en", "Eggs"), zip=True) im = roundtrip(im, pnginfo=info) - self.assertEqual(im.info, {"spam": "Eggs", "eggs": "Spam"}) - self.assertEqual(im.text, {"spam": "Eggs", "eggs": "Spam"}) - self.assertEqual(im.text["spam"].lang, "en") - self.assertEqual(im.text["spam"].tkey, "Spam") - self.assertEqual(im.text["eggs"].lang, "en") - self.assertEqual(im.text["eggs"].tkey, "Eggs") + assert im.info == {"spam": "Eggs", "eggs": "Spam"} + assert im.text == {"spam": "Eggs", "eggs": "Spam"} + assert im.text["spam"].lang == "en" + assert im.text["spam"].tkey == "Spam" + assert im.text["eggs"].lang == "en" + assert im.text["eggs"].tkey == "Eggs" def test_nonunicode_text(self): # Check so that non-Unicode text is saved as a tEXt rather than iTXt @@ -435,7 +437,7 @@ class TestFilePng(PillowTestCase): info = PngImagePlugin.PngInfo() info.add_text("Text", "Ascii") im = roundtrip(im, pnginfo=info) - self.assertIsInstance(im.info["Text"], str) + assert isinstance(im.info["Text"], str) def test_unicode_text(self): # Check preservation of non-ASCII characters @@ -445,7 +447,7 @@ class TestFilePng(PillowTestCase): info = PngImagePlugin.PngInfo() info.add_text("Text", value) im = roundtrip(im, pnginfo=info) - self.assertEqual(im.info, {"Text": value}) + assert im.info == {"Text": value} rt_text(" Aa" + chr(0xA0) + chr(0xC4) + chr(0xFF)) # Latin1 rt_text(chr(0x400) + chr(0x472) + chr(0x4FF)) # Cyrillic @@ -463,7 +465,8 @@ class TestFilePng(PillowTestCase): data = b"\x89" + fd.read() pngfile = BytesIO(data) - self.assertRaises(IOError, Image.open, pngfile) + with pytest.raises(IOError): + Image.open(pngfile) def test_trns_rgb(self): # Check writing and reading of tRNS chunks for RGB images. @@ -471,14 +474,14 @@ class TestFilePng(PillowTestCase): test_file = "Tests/images/caption_6_33_22.png" with Image.open(test_file) as im: - self.assertEqual(im.info["transparency"], (248, 248, 248)) + assert im.info["transparency"] == (248, 248, 248) # check saving transparency by default im = roundtrip(im) - self.assertEqual(im.info["transparency"], (248, 248, 248)) + assert im.info["transparency"] == (248, 248, 248) im = roundtrip(im, transparency=(0, 1, 2)) - self.assertEqual(im.info["transparency"], (0, 1, 2)) + assert im.info["transparency"] == (0, 1, 2) def test_trns_p(self): # Check writing a transparency of 0, issue #528 @@ -489,7 +492,7 @@ class TestFilePng(PillowTestCase): im.save(f) with Image.open(f) as im2: - self.assertIn("transparency", im2.info) + assert "transparency" in im2.info assert_image_equal(im2.convert("RGBA"), im.convert("RGBA")) @@ -498,42 +501,42 @@ class TestFilePng(PillowTestCase): test_file = "Tests/images/tRNS_null_1x1.png" with Image.open(test_file) as im: - self.assertEqual(im.info["transparency"], 0) + assert im.info["transparency"] == 0 def test_save_icc_profile(self): with Image.open("Tests/images/icc_profile_none.png") as im: - self.assertIsNone(im.info["icc_profile"]) + assert im.info["icc_profile"] is None with Image.open("Tests/images/icc_profile.png") as with_icc: expected_icc = with_icc.info["icc_profile"] im = roundtrip(im, icc_profile=expected_icc) - self.assertEqual(im.info["icc_profile"], expected_icc) + assert im.info["icc_profile"] == expected_icc def test_discard_icc_profile(self): with Image.open("Tests/images/icc_profile.png") as im: im = roundtrip(im, icc_profile=None) - self.assertNotIn("icc_profile", im.info) + assert "icc_profile" not in im.info def test_roundtrip_icc_profile(self): with Image.open("Tests/images/icc_profile.png") as im: expected_icc = im.info["icc_profile"] im = roundtrip(im) - self.assertEqual(im.info["icc_profile"], expected_icc) + assert im.info["icc_profile"] == expected_icc def test_roundtrip_no_icc_profile(self): with Image.open("Tests/images/icc_profile_none.png") as im: - self.assertIsNone(im.info["icc_profile"]) + assert im.info["icc_profile"] is None im = roundtrip(im) - self.assertNotIn("icc_profile", im.info) + assert "icc_profile" not in im.info def test_repr_png(self): im = hopper() with Image.open(BytesIO(im._repr_png_())) as repr_png: - self.assertEqual(repr_png.format, "PNG") + assert repr_png.format == "PNG" assert_image_equal(im, repr_png) def test_chunk_order(self): @@ -545,54 +548,55 @@ class TestFilePng(PillowTestCase): # https://www.w3.org/TR/PNG/#5ChunkOrdering # IHDR - shall be first - self.assertEqual(chunks.index(b"IHDR"), 0) + assert chunks.index(b"IHDR") == 0 # PLTE - before first IDAT - self.assertLess(chunks.index(b"PLTE"), chunks.index(b"IDAT")) + assert chunks.index(b"PLTE") < chunks.index(b"IDAT") # iCCP - before PLTE and IDAT - self.assertLess(chunks.index(b"iCCP"), chunks.index(b"PLTE")) - self.assertLess(chunks.index(b"iCCP"), chunks.index(b"IDAT")) + assert chunks.index(b"iCCP") < chunks.index(b"PLTE") + assert chunks.index(b"iCCP") < chunks.index(b"IDAT") # tRNS - after PLTE, before IDAT - self.assertGreater(chunks.index(b"tRNS"), chunks.index(b"PLTE")) - self.assertLess(chunks.index(b"tRNS"), chunks.index(b"IDAT")) + assert chunks.index(b"tRNS") > chunks.index(b"PLTE") + assert chunks.index(b"tRNS") < chunks.index(b"IDAT") # pHYs - before IDAT - self.assertLess(chunks.index(b"pHYs"), chunks.index(b"IDAT")) + assert chunks.index(b"pHYs") < chunks.index(b"IDAT") def test_getchunks(self): im = hopper() chunks = PngImagePlugin.getchunks(im) - self.assertEqual(len(chunks), 3) + assert len(chunks) == 3 def test_textual_chunks_after_idat(self): with Image.open("Tests/images/hopper.png") as im: - self.assertIn("comment", im.text.keys()) + assert "comment" in im.text.keys() for k, v in { "date:create": "2014-09-04T09:37:08+03:00", "date:modify": "2014-09-04T09:37:08+03:00", }.items(): - self.assertEqual(im.text[k], v) + assert im.text[k] == v # Raises a SyntaxError in load_end with Image.open("Tests/images/broken_data_stream.png") as im: - with self.assertRaises(IOError): - self.assertIsInstance(im.text, dict) + with pytest.raises(IOError): + assert isinstance(im.text, dict) # Raises a UnicodeDecodeError in load_end with Image.open("Tests/images/truncated_image.png") as im: # The file is truncated - self.assertRaises(IOError, lambda: im.text) + with pytest.raises(IOError): + im.text() ImageFile.LOAD_TRUNCATED_IMAGES = True - self.assertIsInstance(im.text, dict) + assert isinstance(im.text, dict) ImageFile.LOAD_TRUNCATED_IMAGES = False # Raises an EOFError in load_end with Image.open("Tests/images/hopper_idat_after_image_end.png") as im: - self.assertEqual(im.text, {"TXT": "VALUE", "ZIP": "VALUE"}) + assert im.text == {"TXT": "VALUE", "ZIP": "VALUE"} def test_exif(self): with Image.open("Tests/images/exif.png") as im: exif = im._getexif() - self.assertEqual(exif[274], 1) + assert exif[274] == 1 def test_exif_save(self): with Image.open("Tests/images/exif.png") as im: @@ -601,7 +605,7 @@ class TestFilePng(PillowTestCase): with Image.open(test_file) as reloaded: exif = reloaded._getexif() - self.assertEqual(exif[274], 1) + assert exif[274] == 1 def test_exif_from_jpg(self): with Image.open("Tests/images/pil_sample_rgb.jpg") as im: @@ -610,7 +614,7 @@ class TestFilePng(PillowTestCase): with Image.open(test_file) as reloaded: exif = reloaded._getexif() - self.assertEqual(exif[305], "Adobe Photoshop CS Macintosh") + assert exif[305] == "Adobe Photoshop CS Macintosh" def test_exif_argument(self): with Image.open(TEST_PNG_FILE) as im: @@ -618,13 +622,13 @@ class TestFilePng(PillowTestCase): im.save(test_file, exif=b"exifstring") with Image.open(test_file) as reloaded: - self.assertEqual(reloaded.info["exif"], b"Exif\x00\x00exifstring") + assert reloaded.info["exif"] == b"Exif\x00\x00exifstring" @skip_unless_feature("webp") @skip_unless_feature("webp_anim") def test_apng(self): with Image.open("Tests/images/iss634.apng") as im: - self.assertEqual(im.get_format_mimetype(), "image/apng") + assert im.get_format_mimetype() == "image/apng" # This also tests reading unknown PNG chunks (fcTL and fdAT) in load_end with Image.open("Tests/images/iss634.webp") as expected: diff --git a/Tests/test_file_ppm.py b/Tests/test_file_ppm.py index 8dd99e7bb..dc8daa98f 100644 --- a/Tests/test_file_ppm.py +++ b/Tests/test_file_ppm.py @@ -1,3 +1,4 @@ +import pytest from PIL import Image from .helper import PillowTestCase, assert_image_equal, assert_image_similar, hopper @@ -10,17 +11,17 @@ class TestFilePpm(PillowTestCase): def test_sanity(self): with Image.open(test_file) as im: im.load() - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "PPM") - self.assertEqual(im.get_format_mimetype(), "image/x-portable-pixmap") + assert im.mode == "RGB" + assert im.size == (128, 128) + assert im.format, "PPM" + assert im.get_format_mimetype() == "image/x-portable-pixmap" def test_16bit_pgm(self): with Image.open("Tests/images/16_bit_binary.pgm") as im: im.load() - self.assertEqual(im.mode, "I") - self.assertEqual(im.size, (20, 100)) - self.assertEqual(im.get_format_mimetype(), "image/x-portable-graymap") + assert im.mode == "I" + assert im.size == (20, 100) + assert im.get_format_mimetype() == "image/x-portable-graymap" with Image.open("Tests/images/16_bit_binary_pgm.png") as tgt: assert_image_equal(im, tgt) @@ -50,7 +51,8 @@ class TestFilePpm(PillowTestCase): with open(path, "w") as f: f.write("P6") - self.assertRaises(ValueError, Image.open, path) + with pytest.raises(ValueError): + Image.open(path) def test_neg_ppm(self): # Storage.c accepted negative values for xsize, ysize. the @@ -58,7 +60,7 @@ class TestFilePpm(PillowTestCase): # has been removed. The default opener doesn't accept negative # sizes. - with self.assertRaises(IOError): + with pytest.raises(IOError): Image.open("Tests/images/negative_size.ppm") def test_mimetypes(self): @@ -67,9 +69,9 @@ class TestFilePpm(PillowTestCase): with open(path, "w") as f: f.write("P4\n128 128\n255") with Image.open(path) as im: - self.assertEqual(im.get_format_mimetype(), "image/x-portable-bitmap") + assert im.get_format_mimetype() == "image/x-portable-bitmap" with open(path, "w") as f: f.write("PyCMYK\n128 128\n255") with Image.open(path) as im: - self.assertEqual(im.get_format_mimetype(), "image/x-portable-anymap") + assert im.get_format_mimetype() == "image/x-portable-anymap" diff --git a/Tests/test_file_sgi.py b/Tests/test_file_sgi.py index 586285485..4a606548c 100644 --- a/Tests/test_file_sgi.py +++ b/Tests/test_file_sgi.py @@ -1,3 +1,4 @@ +import pytest from PIL import Image, SgiImagePlugin from .helper import PillowTestCase, assert_image_equal, assert_image_similar, hopper @@ -11,7 +12,7 @@ class TestFileSgi(PillowTestCase): with Image.open(test_file) as im: assert_image_equal(im, hopper()) - self.assertEqual(im.get_format_mimetype(), "image/rgb") + assert im.get_format_mimetype() == "image/rgb" def test_rgb16(self): test_file = "Tests/images/hopper16.rgb" @@ -26,7 +27,7 @@ class TestFileSgi(PillowTestCase): with Image.open(test_file) as im: assert_image_similar(im, hopper("L"), 2) - self.assertEqual(im.get_format_mimetype(), "image/sgi") + assert im.get_format_mimetype() == "image/sgi" def test_rgba(self): # Created with ImageMagick: @@ -36,7 +37,7 @@ class TestFileSgi(PillowTestCase): with Image.open(test_file) as im: with Image.open("Tests/images/transparent.png") as target: assert_image_equal(im, target) - self.assertEqual(im.get_format_mimetype(), "image/sgi") + assert im.get_format_mimetype() == "image/sgi" def test_rle(self): # Created with ImageMagick: @@ -57,7 +58,8 @@ class TestFileSgi(PillowTestCase): def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(ValueError, SgiImagePlugin.SgiImageFile, invalid_file) + with pytest.raises(ValueError): + SgiImagePlugin.SgiImageFile(invalid_file) def test_write(self): def roundtrip(img): @@ -86,4 +88,5 @@ class TestFileSgi(PillowTestCase): im = hopper("LA") out = self.tempfile("temp.sgi") - self.assertRaises(ValueError, im.save, out, format="sgi") + with pytest.raises(ValueError): + im.save(out, format="sgi") diff --git a/Tests/test_file_spider.py b/Tests/test_file_spider.py index 243b5e466..fa299dad5 100644 --- a/Tests/test_file_spider.py +++ b/Tests/test_file_spider.py @@ -14,9 +14,9 @@ class TestImageSpider(PillowTestCase): def test_sanity(self): with Image.open(TEST_FILE) as im: im.load() - self.assertEqual(im.mode, "F") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "SPIDER") + assert im.mode == "F" + assert im.size == (128, 128) + assert im.format == "SPIDER" @unittest.skipIf(is_pypy(), "Requires CPython") def test_unclosed_file(self): @@ -51,9 +51,9 @@ class TestImageSpider(PillowTestCase): # Assert with Image.open(temp) as im2: - self.assertEqual(im2.mode, "F") - self.assertEqual(im2.size, (128, 128)) - self.assertEqual(im2.format, "SPIDER") + assert im2.mode == "F" + assert im2.size == (128, 128) + assert im2.format == "SPIDER" def test_tempfile(self): # Arrange @@ -66,12 +66,12 @@ class TestImageSpider(PillowTestCase): # Assert fp.seek(0) with Image.open(fp) as reloaded: - self.assertEqual(reloaded.mode, "F") - self.assertEqual(reloaded.size, (128, 128)) - self.assertEqual(reloaded.format, "SPIDER") + assert reloaded.mode == "F" + assert reloaded.size == (128, 128) + assert reloaded.format == "SPIDER" def test_isSpiderImage(self): - self.assertTrue(SpiderImagePlugin.isSpiderImage(TEST_FILE)) + assert SpiderImagePlugin.isSpiderImage(TEST_FILE) def test_tell(self): # Arrange @@ -81,12 +81,12 @@ class TestImageSpider(PillowTestCase): index = im.tell() # Assert - self.assertEqual(index, 0) + assert index == 0 def test_n_frames(self): with Image.open(TEST_FILE) as im: - self.assertEqual(im.n_frames, 1) - self.assertFalse(im.is_animated) + assert im.n_frames == 1 + assert not im.is_animated def test_loadImageSeries(self): # Arrange @@ -97,9 +97,9 @@ class TestImageSpider(PillowTestCase): img_list = SpiderImagePlugin.loadImageSeries(file_list) # Assert - self.assertEqual(len(img_list), 1) - self.assertIsInstance(img_list[0], Image.Image) - self.assertEqual(img_list[0].size, (128, 128)) + assert len(img_list) == 1 + assert isinstance(img_list[0], Image.Image) + assert img_list[0].size == (128, 128) def test_loadImageSeries_no_input(self): # Arrange @@ -109,7 +109,7 @@ class TestImageSpider(PillowTestCase): img_list = SpiderImagePlugin.loadImageSeries(file_list) # Assert - self.assertIsNone(img_list) + assert img_list is None def test_isInt_not_a_number(self): # Arrange @@ -119,21 +119,23 @@ class TestImageSpider(PillowTestCase): ret = SpiderImagePlugin.isInt(not_a_number) # Assert - self.assertEqual(ret, 0) + assert ret == 0 def test_invalid_file(self): invalid_file = "Tests/images/invalid.spider" - self.assertRaises(IOError, Image.open, invalid_file) + with pytest.raises(IOError): + Image.open(invalid_file) def test_nonstack_file(self): with Image.open(TEST_FILE) as im: - self.assertRaises(EOFError, im.seek, 0) + with pytest.raises(EOFError): + im.seek(0) def test_nonstack_dos(self): with Image.open(TEST_FILE) as im: for i, frame in enumerate(ImageSequence.Iterator(im)): - self.assertLessEqual(i, 1, "Non-stack DOS file test failed") + assert i <= 1, "Non-stack DOS file test failed" # for issue #4093 def test_odd_size(self): diff --git a/Tests/test_file_tga.py b/Tests/test_file_tga.py index 61d8e7efe..53faa01bd 100644 --- a/Tests/test_file_tga.py +++ b/Tests/test_file_tga.py @@ -26,7 +26,7 @@ class TestFileTga(PillowTestCase): for png_path in png_paths: with Image.open(png_path) as reference_im: - self.assertEqual(reference_im.mode, mode) + assert reference_im.mode == mode path_no_ext = os.path.splitext(png_path)[0] for origin, rle in product(self._ORIGINS, (True, False)): @@ -35,21 +35,18 @@ class TestFileTga(PillowTestCase): ) with Image.open(tga_path) as original_im: - self.assertEqual(original_im.format, "TGA") - self.assertEqual( - original_im.get_format_mimetype(), "image/x-tga" - ) + assert original_im.format == "TGA" + assert original_im.get_format_mimetype() == "image/x-tga" if rle: - self.assertEqual( - original_im.info["compression"], "tga_rle" - ) - self.assertEqual( - original_im.info["orientation"], - self._ORIGIN_TO_ORIENTATION[origin], + assert original_im.info["compression"] == "tga_rle" + assert ( + original_im.info["orientation"] + == self._ORIGIN_TO_ORIENTATION[origin] ) if mode == "P": - self.assertEqual( - original_im.getpalette(), reference_im.getpalette() + assert ( + original_im.getpalette() + == reference_im.getpalette() ) assert_image_equal(original_im, reference_im) @@ -62,17 +59,18 @@ class TestFileTga(PillowTestCase): original_im.save(out, rle=rle) with Image.open(out) as saved_im: if rle: - self.assertEqual( - saved_im.info["compression"], - original_im.info["compression"], + assert ( + saved_im.info["compression"] + == original_im.info["compression"] ) - self.assertEqual( - saved_im.info["orientation"], - original_im.info["orientation"], + assert ( + saved_im.info["orientation"] + == original_im.info["orientation"] ) if mode == "P": - self.assertEqual( - saved_im.getpalette(), original_im.getpalette() + assert ( + saved_im.getpalette() + == original_im.getpalette() ) assert_image_equal(saved_im, original_im) @@ -85,7 +83,7 @@ class TestFileTga(PillowTestCase): with Image.open(test_file) as im: # Assert - self.assertEqual(im.size, (100, 100)) + assert im.size == (100, 100) def test_id_field_rle(self): # tga file with id field @@ -95,7 +93,7 @@ class TestFileTga(PillowTestCase): with Image.open(test_file) as im: # Assert - self.assertEqual(im.size, (199, 199)) + assert im.size == (199, 199) def test_save(self): test_file = "Tests/images/tga_id_field.tga" @@ -105,19 +103,19 @@ class TestFileTga(PillowTestCase): # Save im.save(out) with Image.open(out) as test_im: - self.assertEqual(test_im.size, (100, 100)) - self.assertEqual(test_im.info["id_section"], im.info["id_section"]) + assert test_im.size == (100, 100) + assert test_im.info["id_section"] == im.info["id_section"] # RGBA save im.convert("RGBA").save(out) with Image.open(out) as test_im: - self.assertEqual(test_im.size, (100, 100)) + assert test_im.size == (100, 100) def test_save_wrong_mode(self): im = hopper("PA") out = self.tempfile("temp.tga") - with self.assertRaises(OSError): + with pytest.raises(OSError): im.save(out) def test_save_id_section(self): @@ -128,18 +126,18 @@ class TestFileTga(PillowTestCase): # Check there is no id section im.save(out) with Image.open(out) as test_im: - self.assertNotIn("id_section", test_im.info) + assert "id_section" not in test_im.info # Save with custom id section im.save(out, id_section=b"Test content") with Image.open(out) as test_im: - self.assertEqual(test_im.info["id_section"], b"Test content") + assert test_im.info["id_section"] == b"Test content" # Save with custom id section greater than 255 characters id_section = b"Test content" * 25 pytest.warns(UserWarning, lambda: im.save(out, id_section=id_section)) with Image.open(out) as test_im: - self.assertEqual(test_im.info["id_section"], id_section[:255]) + assert test_im.info["id_section"] == id_section[:255] test_file = "Tests/images/tga_id_field.tga" with Image.open(test_file) as im: @@ -147,49 +145,49 @@ class TestFileTga(PillowTestCase): # Save with no id section im.save(out, id_section="") with Image.open(out) as test_im: - self.assertNotIn("id_section", test_im.info) + assert "id_section" not in test_im.info def test_save_orientation(self): test_file = "Tests/images/rgb32rle.tga" out = self.tempfile("temp.tga") with Image.open(test_file) as im: - self.assertEqual(im.info["orientation"], -1) + assert im.info["orientation"] == -1 im.save(out, orientation=1) with Image.open(out) as test_im: - self.assertEqual(test_im.info["orientation"], 1) + assert test_im.info["orientation"] == 1 def test_save_rle(self): test_file = "Tests/images/rgb32rle.tga" with Image.open(test_file) as im: - self.assertEqual(im.info["compression"], "tga_rle") + assert im.info["compression"] == "tga_rle" out = self.tempfile("temp.tga") # Save im.save(out) with Image.open(out) as test_im: - self.assertEqual(test_im.size, (199, 199)) - self.assertEqual(test_im.info["compression"], "tga_rle") + assert test_im.size == (199, 199) + assert test_im.info["compression"] == "tga_rle" # Save without compression im.save(out, compression=None) with Image.open(out) as test_im: - self.assertNotIn("compression", test_im.info) + assert "compression" not in test_im.info # RGBA save im.convert("RGBA").save(out) with Image.open(out) as test_im: - self.assertEqual(test_im.size, (199, 199)) + assert test_im.size == (199, 199) test_file = "Tests/images/tga_id_field.tga" with Image.open(test_file) as im: - self.assertNotIn("compression", im.info) + assert "compression" not in im.info # Save with compression im.save(out, compression="tga_rle") with Image.open(out) as test_im: - self.assertEqual(test_im.info["compression"], "tga_rle") + assert test_im.info["compression"] == "tga_rle" def test_save_l_transparency(self): # There are 559 transparent pixels in la.tga. @@ -197,14 +195,14 @@ class TestFileTga(PillowTestCase): in_file = "Tests/images/la.tga" with Image.open(in_file) as im: - self.assertEqual(im.mode, "LA") - self.assertEqual(im.getchannel("A").getcolors()[0][0], num_transparent) + assert im.mode == "LA" + assert im.getchannel("A").getcolors()[0][0] == num_transparent out = self.tempfile("temp.tga") im.save(out) with Image.open(out) as test_im: - self.assertEqual(test_im.mode, "LA") - self.assertEqual(test_im.getchannel("A").getcolors()[0][0], num_transparent) + assert test_im.mode == "LA" + assert test_im.getchannel("A").getcolors()[0][0] == num_transparent assert_image_equal(im, test_im) diff --git a/Tests/test_file_tiff.py b/Tests/test_file_tiff.py index 8140fa3fe..0569e15cc 100644 --- a/Tests/test_file_tiff.py +++ b/Tests/test_file_tiff.py @@ -30,9 +30,9 @@ class TestFileTiff(PillowTestCase): with Image.open(filename) as im: im.load() - self.assertEqual(im.mode, "RGB") - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.format, "TIFF") + assert im.mode == "RGB" + assert im.size == (128, 128) + assert im.format == "TIFF" hopper("1").save(filename) with Image.open(filename): @@ -82,53 +82,54 @@ class TestFileTiff(PillowTestCase): filename = "Tests/images/pil136.tiff" with Image.open(filename) as im: - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (55, 43)) - self.assertEqual(im.tile, [("raw", (0, 0, 55, 43), 8, ("RGBa", 0, 1))]) + assert im.mode == "RGBA" + assert im.size == (55, 43) + assert im.tile == [("raw", (0, 0, 55, 43), 8, ("RGBa", 0, 1))] im.load() assert_image_similar_tofile(im, "Tests/images/pil136.png", 1) def test_wrong_bits_per_sample(self): with Image.open("Tests/images/tiff_wrong_bits_per_sample.tiff") as im: - self.assertEqual(im.mode, "RGBA") - self.assertEqual(im.size, (52, 53)) - self.assertEqual(im.tile, [("raw", (0, 0, 52, 53), 160, ("RGBA", 0, 1))]) + assert im.mode == "RGBA" + assert im.size == (52, 53) + assert im.tile == [("raw", (0, 0, 52, 53), 160, ("RGBA", 0, 1))] im.load() def test_set_legacy_api(self): ifd = TiffImagePlugin.ImageFileDirectory_v2() - with self.assertRaises(Exception) as e: + with pytest.raises(Exception) as e: ifd.legacy_api = None - self.assertEqual(str(e.exception), "Not allowing setting of legacy api") + assert str(e.value) == "Not allowing setting of legacy api" def test_xyres_tiff(self): filename = "Tests/images/pil168.tif" with Image.open(filename) as im: # legacy api - self.assertIsInstance(im.tag[X_RESOLUTION][0], tuple) - self.assertIsInstance(im.tag[Y_RESOLUTION][0], tuple) + assert isinstance(im.tag[X_RESOLUTION][0], tuple) + assert isinstance(im.tag[Y_RESOLUTION][0], tuple) # v2 api - self.assertIsInstance(im.tag_v2[X_RESOLUTION], TiffImagePlugin.IFDRational) - self.assertIsInstance(im.tag_v2[Y_RESOLUTION], TiffImagePlugin.IFDRational) + assert isinstance(im.tag_v2[X_RESOLUTION], TiffImagePlugin.IFDRational) + assert isinstance(im.tag_v2[Y_RESOLUTION], TiffImagePlugin.IFDRational) - self.assertEqual(im.info["dpi"], (72.0, 72.0)) + assert im.info["dpi"] == (72.0, 72.0) def test_xyres_fallback_tiff(self): filename = "Tests/images/compression.tif" with Image.open(filename) as im: # v2 api - self.assertIsInstance(im.tag_v2[X_RESOLUTION], TiffImagePlugin.IFDRational) - self.assertIsInstance(im.tag_v2[Y_RESOLUTION], TiffImagePlugin.IFDRational) - self.assertRaises(KeyError, lambda: im.tag_v2[RESOLUTION_UNIT]) + assert isinstance(im.tag_v2[X_RESOLUTION], TiffImagePlugin.IFDRational) + assert isinstance(im.tag_v2[Y_RESOLUTION], TiffImagePlugin.IFDRational) + with pytest.raises(KeyError): + im.tag_v2[RESOLUTION_UNIT] # Legacy. - self.assertEqual(im.info["resolution"], (100.0, 100.0)) + assert im.info["resolution"] == (100.0, 100.0) # Fallback "inch". - self.assertEqual(im.info["dpi"], (100.0, 100.0)) + assert im.info["dpi"] == (100.0, 100.0) def test_int_resolution(self): filename = "Tests/images/pil168.tif" @@ -138,21 +139,21 @@ class TestFileTiff(PillowTestCase): im.tag_v2[X_RESOLUTION] = 71 im.tag_v2[Y_RESOLUTION] = 71 im._setup() - self.assertEqual(im.info["dpi"], (71.0, 71.0)) + assert im.info["dpi"] == (71.0, 71.0) def test_load_dpi_rounding(self): for resolutionUnit, dpi in ((None, (72, 73)), (2, (72, 73)), (3, (183, 185))): with Image.open( "Tests/images/hopper_roundDown_" + str(resolutionUnit) + ".tif" ) as im: - self.assertEqual(im.tag_v2.get(RESOLUTION_UNIT), resolutionUnit) - self.assertEqual(im.info["dpi"], (dpi[0], dpi[0])) + assert im.tag_v2.get(RESOLUTION_UNIT) == resolutionUnit + assert im.info["dpi"] == (dpi[0], dpi[0]) with Image.open( "Tests/images/hopper_roundUp_" + str(resolutionUnit) + ".tif" ) as im: - self.assertEqual(im.tag_v2.get(RESOLUTION_UNIT), resolutionUnit) - self.assertEqual(im.info["dpi"], (dpi[1], dpi[1])) + assert im.tag_v2.get(RESOLUTION_UNIT) == resolutionUnit + assert im.info["dpi"] == (dpi[1], dpi[1]) def test_save_dpi_rounding(self): outfile = self.tempfile("temp.tif") @@ -162,7 +163,7 @@ class TestFileTiff(PillowTestCase): with Image.open(outfile) as reloaded: reloaded.load() - self.assertEqual((round(dpi), round(dpi)), reloaded.info["dpi"]) + assert (round(dpi), round(dpi)) == reloaded.info["dpi"] def test_save_setting_missing_resolution(self): b = BytesIO() @@ -170,16 +171,18 @@ class TestFileTiff(PillowTestCase): b, format="tiff", resolution=123.45 ) with Image.open(b) as im: - self.assertEqual(float(im.tag_v2[X_RESOLUTION]), 123.45) - self.assertEqual(float(im.tag_v2[Y_RESOLUTION]), 123.45) + assert float(im.tag_v2[X_RESOLUTION]) == 123.45 + assert float(im.tag_v2[Y_RESOLUTION]) == 123.45 def test_invalid_file(self): invalid_file = "Tests/images/flower.jpg" - self.assertRaises(SyntaxError, TiffImagePlugin.TiffImageFile, invalid_file) + with pytest.raises(SyntaxError): + TiffImagePlugin.TiffImageFile(invalid_file) TiffImagePlugin.PREFIXES.append(b"\xff\xd8\xff\xe0") - self.assertRaises(SyntaxError, TiffImagePlugin.TiffImageFile, invalid_file) + with pytest.raises(SyntaxError): + TiffImagePlugin.TiffImageFile(invalid_file) TiffImagePlugin.PREFIXES.pop() def test_bad_exif(self): @@ -195,34 +198,35 @@ class TestFileTiff(PillowTestCase): def test_save_unsupported_mode(self): im = hopper("HSV") outfile = self.tempfile("temp.tif") - self.assertRaises(IOError, im.save, outfile) + with pytest.raises(IOError): + im.save(outfile) def test_little_endian(self): with Image.open("Tests/images/16bit.cropped.tif") as im: - self.assertEqual(im.getpixel((0, 0)), 480) - self.assertEqual(im.mode, "I;16") + assert im.getpixel((0, 0)) == 480 + assert im.mode == "I;16" b = im.tobytes() # Bytes are in image native order (little endian) - self.assertEqual(b[0], ord(b"\xe0")) - self.assertEqual(b[1], ord(b"\x01")) + assert b[0] == ord(b"\xe0") + assert b[1] == ord(b"\x01") def test_big_endian(self): with Image.open("Tests/images/16bit.MM.cropped.tif") as im: - self.assertEqual(im.getpixel((0, 0)), 480) - self.assertEqual(im.mode, "I;16B") + assert im.getpixel((0, 0)) == 480 + assert im.mode == "I;16B" b = im.tobytes() # Bytes are in image native order (big endian) - self.assertEqual(b[0], ord(b"\x01")) - self.assertEqual(b[1], ord(b"\xe0")) + assert b[0] == ord(b"\x01") + assert b[1] == ord(b"\xe0") def test_16bit_s(self): with Image.open("Tests/images/16bit.s.tif") as im: im.load() - self.assertEqual(im.mode, "I") - self.assertEqual(im.getpixel((0, 0)), 32767) - self.assertEqual(im.getpixel((0, 1)), 0) + assert im.mode == "I" + assert im.getpixel((0, 0)) == 32767 + assert im.getpixel((0, 1)) == 0 def test_12bit_rawmode(self): """ Are we generating the same interpretation @@ -243,13 +247,12 @@ class TestFileTiff(PillowTestCase): with Image.open(path) as im: im.load() - self.assertEqual(im.getpixel((0, 0)), -0.4526388943195343) - self.assertEqual(im.getextrema(), (-3.140936851501465, 3.140684127807617)) + assert im.getpixel((0, 0)) == -0.4526388943195343 + assert im.getextrema() == (-3.140936851501465, 3.140684127807617) def test_unknown_pixel_mode(self): - self.assertRaises( - IOError, Image.open, "Tests/images/hopper_unknown_pixel_mode.tif" - ) + with pytest.raises(IOError): + Image.open("Tests/images/hopper_unknown_pixel_mode.tif") def test_n_frames(self): for path, n_frames in [ @@ -257,16 +260,17 @@ class TestFileTiff(PillowTestCase): ["Tests/images/multipage.tiff", 3], ]: with Image.open(path) as im: - self.assertEqual(im.n_frames, n_frames) - self.assertEqual(im.is_animated, n_frames != 1) + assert im.n_frames == n_frames + assert im.is_animated == (n_frames != 1) def test_eoferror(self): with Image.open("Tests/images/multipage-lastframe.tif") as im: n_frames = im.n_frames # Test seeking past the last frame - self.assertRaises(EOFError, im.seek, n_frames) - self.assertLess(im.tell(), n_frames) + with pytest.raises(EOFError): + im.seek(n_frames) + assert im.tell() < n_frames # Test that seeking to the last frame does not raise an error im.seek(n_frames - 1) @@ -277,29 +281,29 @@ class TestFileTiff(PillowTestCase): # file is a multipage tiff: 10x10 green, 10x10 red, 20x20 blue im.seek(0) - self.assertEqual(im.size, (10, 10)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 128, 0)) + assert im.size == (10, 10) + assert im.convert("RGB").getpixel((0, 0)) == (0, 128, 0) im.seek(1) im.load() - self.assertEqual(im.size, (10, 10)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (255, 0, 0)) + assert im.size == (10, 10) + assert im.convert("RGB").getpixel((0, 0)) == (255, 0, 0) im.seek(0) im.load() - self.assertEqual(im.size, (10, 10)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 128, 0)) + assert im.size == (10, 10) + assert im.convert("RGB").getpixel((0, 0)) == (0, 128, 0) im.seek(2) im.load() - self.assertEqual(im.size, (20, 20)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 0, 255)) + assert im.size == (20, 20) + assert im.convert("RGB").getpixel((0, 0)) == (0, 0, 255) def test_multipage_last_frame(self): with Image.open("Tests/images/multipage-lastframe.tif") as im: im.load() - self.assertEqual(im.size, (20, 20)) - self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 0, 255)) + assert im.size == (20, 20) + assert im.convert("RGB").getpixel((0, 0)) == (0, 0, 255) def test___str__(self): filename = "Tests/images/pil136.tiff" @@ -309,7 +313,7 @@ class TestFileTiff(PillowTestCase): ret = str(im.ifd) # Assert - self.assertIsInstance(ret, str) + assert isinstance(ret, str) def test_dict(self): # Arrange @@ -332,7 +336,7 @@ class TestFileTiff(PillowTestCase): 283: 72.0, 284: 1, } - self.assertEqual(dict(im.tag_v2), v2_tags) + assert dict(im.tag_v2) == v2_tags # legacy interface legacy_tags = { @@ -350,7 +354,7 @@ class TestFileTiff(PillowTestCase): 283: ((720000, 10000),), 284: (1,), } - self.assertEqual(dict(im.tag), legacy_tags) + assert dict(im.tag) == legacy_tags def test__delitem__(self): filename = "Tests/images/pil136.tiff" @@ -358,66 +362,68 @@ class TestFileTiff(PillowTestCase): len_before = len(dict(im.ifd)) del im.ifd[256] len_after = len(dict(im.ifd)) - self.assertEqual(len_before, len_after + 1) + assert len_before == len_after + 1 def test_load_byte(self): for legacy_api in [False, True]: ifd = TiffImagePlugin.ImageFileDirectory_v2() data = b"abc" ret = ifd.load_byte(data, legacy_api) - self.assertEqual(ret, b"abc") + assert ret == b"abc" def test_load_string(self): ifd = TiffImagePlugin.ImageFileDirectory_v2() data = b"abc\0" ret = ifd.load_string(data, False) - self.assertEqual(ret, "abc") + assert ret == "abc" def test_load_float(self): ifd = TiffImagePlugin.ImageFileDirectory_v2() data = b"abcdabcd" ret = ifd.load_float(data, False) - self.assertEqual(ret, (1.6777999408082104e22, 1.6777999408082104e22)) + assert ret == (1.6777999408082104e22, 1.6777999408082104e22) def test_load_double(self): ifd = TiffImagePlugin.ImageFileDirectory_v2() data = b"abcdefghabcdefgh" ret = ifd.load_double(data, False) - self.assertEqual(ret, (8.540883223036124e194, 8.540883223036124e194)) + assert ret == (8.540883223036124e194, 8.540883223036124e194) def test_seek(self): filename = "Tests/images/pil136.tiff" with Image.open(filename) as im: im.seek(0) - self.assertEqual(im.tell(), 0) + assert im.tell() == 0 def test_seek_eof(self): filename = "Tests/images/pil136.tiff" with Image.open(filename) as im: - self.assertEqual(im.tell(), 0) - self.assertRaises(EOFError, im.seek, -1) - self.assertRaises(EOFError, im.seek, 1) + assert im.tell() == 0 + with pytest.raises(EOFError): + im.seek(-1) + with pytest.raises(EOFError): + im.seek(1) def test__limit_rational_int(self): from PIL.TiffImagePlugin import _limit_rational value = 34 ret = _limit_rational(value, 65536) - self.assertEqual(ret, (34, 1)) + assert ret == (34, 1) def test__limit_rational_float(self): from PIL.TiffImagePlugin import _limit_rational value = 22.3 ret = _limit_rational(value, 65536) - self.assertEqual(ret, (223, 10)) + assert ret == (223, 10) def test_4bit(self): test_file = "Tests/images/hopper_gray_4bpp.tif" original = hopper("L") with Image.open(test_file) as im: - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.mode, "L") + assert im.size == (128, 128) + assert im.mode == "L" assert_image_similar(im, original, 7.3) def test_gray_semibyte_per_pixel(self): @@ -444,13 +450,13 @@ class TestFileTiff(PillowTestCase): original = hopper("L") for epsilon, group in test_files: with Image.open(group[0]) as im: - self.assertEqual(im.size, (128, 128)) - self.assertEqual(im.mode, "L") + assert im.size == (128, 128) + assert im.mode == "L" assert_image_similar(im, original, epsilon) for file in group[1:]: with Image.open(file) as im2: - self.assertEqual(im2.size, (128, 128)) - self.assertEqual(im2.mode, "L") + assert im2.size == (128, 128) + assert im2.mode == "L" assert_image_equal(im, im2) def test_with_underscores(self): @@ -460,19 +466,19 @@ class TestFileTiff(PillowTestCase): with Image.open(filename) as im: # legacy interface - self.assertEqual(im.tag[X_RESOLUTION][0][0], 72) - self.assertEqual(im.tag[Y_RESOLUTION][0][0], 36) + assert im.tag[X_RESOLUTION][0][0] == 72 + assert im.tag[Y_RESOLUTION][0][0] == 36 # v2 interface - self.assertEqual(im.tag_v2[X_RESOLUTION], 72) - self.assertEqual(im.tag_v2[Y_RESOLUTION], 36) + assert im.tag_v2[X_RESOLUTION] == 72 + assert im.tag_v2[Y_RESOLUTION] == 36 def test_roundtrip_tiff_uint16(self): # Test an image of all '0' values pixel_value = 0x1234 infile = "Tests/images/uint16_1_4660.tif" with Image.open(infile) as im: - self.assertEqual(im.getpixel((0, 0)), pixel_value) + assert im.getpixel((0, 0)) == pixel_value tmpfile = self.tempfile("temp.tif") im.save(tmpfile) @@ -523,7 +529,7 @@ class TestFileTiff(PillowTestCase): mp.seek(0, os.SEEK_SET) with Image.open(mp) as im: - self.assertEqual(im.n_frames, 3) + assert im.n_frames == 3 # Test appending images mp = BytesIO() @@ -533,7 +539,7 @@ class TestFileTiff(PillowTestCase): mp.seek(0, os.SEEK_SET) with Image.open(mp) as reread: - self.assertEqual(reread.n_frames, 3) + assert reread.n_frames == 3 # Test appending using a generator def imGenerator(ims): @@ -544,7 +550,7 @@ class TestFileTiff(PillowTestCase): mp.seek(0, os.SEEK_SET) with Image.open(mp) as reread: - self.assertEqual(reread.n_frames, 3) + assert reread.n_frames == 3 def test_saving_icc_profile(self): # Tests saving TIFF with icc_profile set. @@ -558,7 +564,7 @@ class TestFileTiff(PillowTestCase): tmpfile = self.tempfile("temp.tif") im.save(tmpfile, "TIFF", compression="raw") with Image.open(tmpfile) as reloaded: - self.assertEqual(b"Dummy value", reloaded.info["icc_profile"]) + assert b"Dummy value" == reloaded.info["icc_profile"] def test_close_on_load_exclusive(self): # similar to test_fd_leak, but runs on unixlike os @@ -569,9 +575,9 @@ class TestFileTiff(PillowTestCase): im = Image.open(tmpfile) fp = im.fp - self.assertFalse(fp.closed) + assert not fp.closed im.load() - self.assertTrue(fp.closed) + assert fp.closed def test_close_on_load_nonexclusive(self): tmpfile = self.tempfile("temp.tif") @@ -582,16 +588,16 @@ class TestFileTiff(PillowTestCase): with open(tmpfile, "rb") as f: im = Image.open(f) fp = im.fp - self.assertFalse(fp.closed) + assert not fp.closed im.load() - self.assertFalse(fp.closed) + assert not fp.closed # Ignore this UserWarning which triggers for four tags: # "Possibly corrupt EXIF data. Expecting to read 50404352 bytes but..." @pytest.mark.filterwarnings("ignore:Possibly corrupt EXIF data") def test_string_dimension(self): # Assert that an error is raised if one of the dimensions is a string - with self.assertRaises(ValueError): + with pytest.raises(ValueError): Image.open("Tests/images/string_dimension.tiff") @@ -606,10 +612,11 @@ class TestFileTiffW32(PillowTestCase): im = Image.open(tmpfile) fp = im.fp - self.assertFalse(fp.closed) - self.assertRaises(WindowsError, os.remove, tmpfile) + assert not fp.closed + with pytest.raises(WindowsError): + os.remove(tmpfile) im.load() - self.assertTrue(fp.closed) + assert fp.closed # this closes the mmap im.close() diff --git a/Tests/test_file_tiff_metadata.py b/Tests/test_file_tiff_metadata.py index 5a9ca9d63..a00bd1c73 100644 --- a/Tests/test_file_tiff_metadata.py +++ b/Tests/test_file_tiff_metadata.py @@ -55,14 +55,14 @@ class TestFileTiffMetadata(PillowTestCase): with Image.open(f) as loaded: - self.assertEqual(loaded.tag[ImageJMetaDataByteCounts], (len(bindata),)) - self.assertEqual(loaded.tag_v2[ImageJMetaDataByteCounts], (len(bindata),)) + assert loaded.tag[ImageJMetaDataByteCounts] == (len(bindata),) + assert loaded.tag_v2[ImageJMetaDataByteCounts] == (len(bindata),) - self.assertEqual(loaded.tag[ImageJMetaData], bindata) - self.assertEqual(loaded.tag_v2[ImageJMetaData], bindata) + assert loaded.tag[ImageJMetaData] == bindata + assert loaded.tag_v2[ImageJMetaData] == bindata - self.assertEqual(loaded.tag[ImageDescription], (reloaded_textdata,)) - self.assertEqual(loaded.tag_v2[ImageDescription], reloaded_textdata) + assert loaded.tag[ImageDescription] == (reloaded_textdata,) + assert loaded.tag_v2[ImageDescription] == reloaded_textdata loaded_float = loaded.tag[tag_ids["RollAngle"]][0] self.assertAlmostEqual(loaded_float, floatdata, places=5) @@ -75,59 +75,49 @@ class TestFileTiffMetadata(PillowTestCase): img.save(f, tiffinfo=info) with Image.open(f) as loaded: - self.assertEqual( - loaded.tag[ImageJMetaDataByteCounts], (8, len(bindata) - 8) - ) - self.assertEqual( - loaded.tag_v2[ImageJMetaDataByteCounts], (8, len(bindata) - 8) - ) + assert loaded.tag[ImageJMetaDataByteCounts] == (8, len(bindata) - 8) + assert loaded.tag_v2[ImageJMetaDataByteCounts] == (8, len(bindata) - 8) def test_read_metadata(self): with Image.open("Tests/images/hopper_g4.tif") as img: - self.assertEqual( - { - "YResolution": IFDRational(4294967295, 113653537), - "PlanarConfiguration": 1, - "BitsPerSample": (1,), - "ImageLength": 128, - "Compression": 4, - "FillOrder": 1, - "RowsPerStrip": 128, - "ResolutionUnit": 3, - "PhotometricInterpretation": 0, - "PageNumber": (0, 1), - "XResolution": IFDRational(4294967295, 113653537), - "ImageWidth": 128, - "Orientation": 1, - "StripByteCounts": (1968,), - "SamplesPerPixel": 1, - "StripOffsets": (8,), - }, - img.tag_v2.named(), - ) + assert { + "YResolution": IFDRational(4294967295, 113653537), + "PlanarConfiguration": 1, + "BitsPerSample": (1,), + "ImageLength": 128, + "Compression": 4, + "FillOrder": 1, + "RowsPerStrip": 128, + "ResolutionUnit": 3, + "PhotometricInterpretation": 0, + "PageNumber": (0, 1), + "XResolution": IFDRational(4294967295, 113653537), + "ImageWidth": 128, + "Orientation": 1, + "StripByteCounts": (1968,), + "SamplesPerPixel": 1, + "StripOffsets": (8,), + } == img.tag_v2.named() - self.assertEqual( - { - "YResolution": ((4294967295, 113653537),), - "PlanarConfiguration": (1,), - "BitsPerSample": (1,), - "ImageLength": (128,), - "Compression": (4,), - "FillOrder": (1,), - "RowsPerStrip": (128,), - "ResolutionUnit": (3,), - "PhotometricInterpretation": (0,), - "PageNumber": (0, 1), - "XResolution": ((4294967295, 113653537),), - "ImageWidth": (128,), - "Orientation": (1,), - "StripByteCounts": (1968,), - "SamplesPerPixel": (1,), - "StripOffsets": (8,), - }, - img.tag.named(), - ) + assert { + "YResolution": ((4294967295, 113653537),), + "PlanarConfiguration": (1,), + "BitsPerSample": (1,), + "ImageLength": (128,), + "Compression": (4,), + "FillOrder": (1,), + "RowsPerStrip": (128,), + "ResolutionUnit": (3,), + "PhotometricInterpretation": (0,), + "PageNumber": (0, 1), + "XResolution": ((4294967295, 113653537),), + "ImageWidth": (128,), + "Orientation": (1,), + "StripByteCounts": (1968,), + "SamplesPerPixel": (1,), + "StripOffsets": (8,), + } == img.tag.named() def test_write_metadata(self): """ Test metadata writing through the python code """ @@ -156,19 +146,17 @@ class TestFileTiffMetadata(PillowTestCase): "{} didn't roundtrip, {}, {}".format(tag, original[tag], value), ) else: - self.assertEqual( - original[tag], - value, - "{} didn't roundtrip, {}, {}".format(tag, original[tag], value), + assert original[tag] == value, "{} didn't roundtrip, {}, {}".format( + tag, original[tag], value ) for tag, value in original.items(): if tag not in ignored: - self.assertEqual(value, reloaded[tag], "%s didn't roundtrip" % tag) + assert value == reloaded[tag], "%s didn't roundtrip" % tag def test_no_duplicate_50741_tag(self): - self.assertEqual(tag_ids["MakerNoteSafety"], 50741) - self.assertEqual(tag_ids["BestQualityScale"], 50780) + assert tag_ids["MakerNoteSafety"] == 50741 + assert tag_ids["BestQualityScale"] == 50780 def test_empty_metadata(self): f = io.BytesIO(b"II*\x00\x08\x00\x00\x00") @@ -184,8 +172,8 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out) with Image.open(out) as reloaded: - self.assertNotIsInstance(im.info["icc_profile"], tuple) - self.assertEqual(im.info["icc_profile"], reloaded.info["icc_profile"]) + assert not isinstance(im.info["icc_profile"], tuple) + assert im.info["icc_profile"] == reloaded.info["icc_profile"] def test_iccprofile_binary(self): # https://github.com/python-pillow/Pillow/issues/1526 @@ -193,8 +181,8 @@ class TestFileTiffMetadata(PillowTestCase): # but probably won't be able to save it. with Image.open("Tests/images/hopper.iccprofile_binary.tif") as im: - self.assertEqual(im.tag_v2.tagtype[34675], 1) - self.assertTrue(im.info["icc_profile"]) + assert im.tag_v2.tagtype[34675] == 1 + assert im.info["icc_profile"] def test_iccprofile_save_png(self): with Image.open("Tests/images/hopper.iccprofile.tif") as im: @@ -215,8 +203,8 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out, tiffinfo=info, compression="raw") with Image.open(out) as reloaded: - self.assertEqual(0, reloaded.tag_v2[41988].numerator) - self.assertEqual(0, reloaded.tag_v2[41988].denominator) + assert 0 == reloaded.tag_v2[41988].numerator + assert 0 == reloaded.tag_v2[41988].denominator def test_ifd_unsigned_rational(self): im = hopper() @@ -233,8 +221,8 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out, tiffinfo=info, compression="raw") with Image.open(out) as reloaded: - self.assertEqual(max_long, reloaded.tag_v2[41493].numerator) - self.assertEqual(1, reloaded.tag_v2[41493].denominator) + assert max_long == reloaded.tag_v2[41493].numerator + assert 1 == reloaded.tag_v2[41493].denominator # out of bounds of 4 byte unsigned long numerator = max_long + 1 @@ -245,8 +233,8 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out, tiffinfo=info, compression="raw") with Image.open(out) as reloaded: - self.assertEqual(max_long, reloaded.tag_v2[41493].numerator) - self.assertEqual(1, reloaded.tag_v2[41493].denominator) + assert max_long == reloaded.tag_v2[41493].numerator + assert 1 == reloaded.tag_v2[41493].denominator def test_ifd_signed_rational(self): im = hopper() @@ -262,8 +250,8 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out, tiffinfo=info, compression="raw") with Image.open(out) as reloaded: - self.assertEqual(numerator, reloaded.tag_v2[37380].numerator) - self.assertEqual(denominator, reloaded.tag_v2[37380].denominator) + assert numerator == reloaded.tag_v2[37380].numerator + assert denominator == reloaded.tag_v2[37380].denominator numerator = -(2 ** 31) denominator = 2 ** 31 - 1 @@ -274,8 +262,8 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out, tiffinfo=info, compression="raw") with Image.open(out) as reloaded: - self.assertEqual(numerator, reloaded.tag_v2[37380].numerator) - self.assertEqual(denominator, reloaded.tag_v2[37380].denominator) + assert numerator == reloaded.tag_v2[37380].numerator + assert denominator == reloaded.tag_v2[37380].denominator # out of bounds of 4 byte signed long numerator = -(2 ** 31) - 1 @@ -287,8 +275,8 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out, tiffinfo=info, compression="raw") with Image.open(out) as reloaded: - self.assertEqual(2 ** 31 - 1, reloaded.tag_v2[37380].numerator) - self.assertEqual(-1, reloaded.tag_v2[37380].denominator) + assert 2 ** 31 - 1 == reloaded.tag_v2[37380].numerator + assert -1 == reloaded.tag_v2[37380].denominator def test_ifd_signed_long(self): im = hopper() @@ -300,7 +288,7 @@ class TestFileTiffMetadata(PillowTestCase): im.save(out, tiffinfo=info, compression="raw") with Image.open(out) as reloaded: - self.assertEqual(reloaded.tag_v2[37000], -60000) + assert reloaded.tag_v2[37000] == -60000 def test_empty_values(self): data = io.BytesIO( @@ -314,17 +302,17 @@ class TestFileTiffMetadata(PillowTestCase): info.load(data) # Should not raise ValueError. info = dict(info) - self.assertIn(33432, info) + assert 33432 in info def test_PhotoshopInfo(self): with Image.open("Tests/images/issue_2278.tif") as im: - self.assertEqual(len(im.tag_v2[34377]), 1) - self.assertIsInstance(im.tag_v2[34377][0], bytes) + assert len(im.tag_v2[34377]) == 1 + assert isinstance(im.tag_v2[34377][0], bytes) out = self.tempfile("temp.tiff") im.save(out) with Image.open(out) as reloaded: - self.assertEqual(len(reloaded.tag_v2[34377]), 1) - self.assertIsInstance(reloaded.tag_v2[34377][0], bytes) + assert len(reloaded.tag_v2[34377]) == 1 + assert isinstance(reloaded.tag_v2[34377][0], bytes) def test_too_many_entries(self): ifd = TiffImagePlugin.ImageFileDirectory_v2() diff --git a/Tests/test_file_webp.py b/Tests/test_file_webp.py index df179d256..5f9176af0 100644 --- a/Tests/test_file_webp.py +++ b/Tests/test_file_webp.py @@ -47,9 +47,9 @@ class TestFileWebp(PillowTestCase): """ with Image.open("Tests/images/hopper.webp") as image: - self.assertEqual(image.mode, self.rgb_mode) - self.assertEqual(image.size, (128, 128)) - self.assertEqual(image.format, "WEBP") + assert image.mode == self.rgb_mode + assert image.size == (128, 128) + assert image.format == "WEBP" image.load() image.getdata() @@ -67,9 +67,9 @@ class TestFileWebp(PillowTestCase): hopper(self.rgb_mode).save(temp_file) with Image.open(temp_file) as image: - self.assertEqual(image.mode, self.rgb_mode) - self.assertEqual(image.size, (128, 128)) - self.assertEqual(image.format, "WEBP") + assert image.mode == self.rgb_mode + assert image.size == (128, 128) + assert image.format == "WEBP" image.load() image.getdata() @@ -95,9 +95,9 @@ class TestFileWebp(PillowTestCase): temp_file = self.tempfile("temp.webp") hopper("L").save(temp_file) with Image.open(temp_file) as image: - self.assertEqual(image.mode, self.rgb_mode) - self.assertEqual(image.size, (128, 128)) - self.assertEqual(image.format, "WEBP") + assert image.mode == self.rgb_mode + assert image.size == (128, 128) + assert image.format == "WEBP" image.load() image.getdata() @@ -114,9 +114,9 @@ class TestFileWebp(PillowTestCase): temp_file = self.tempfile("temp.webp") hopper("P").save(temp_file) with Image.open(temp_file) as image: - self.assertEqual(image.mode, self.rgb_mode) - self.assertEqual(image.size, (128, 128)) - self.assertEqual(image.format, "WEBP") + assert image.mode == self.rgb_mode + assert image.size == (128, 128) + assert image.format == "WEBP" image.load() image.getdata() @@ -130,8 +130,10 @@ class TestFileWebp(PillowTestCase): """ if _webp.HAVE_WEBPANIM: - self.assertRaises(TypeError, _webp.WebPAnimEncoder) - self.assertRaises(TypeError, _webp.WebPEncode) + with pytest.raises(TypeError): + _webp.WebPAnimEncoder() + with pytest.raises(TypeError): + _webp.WebPEncode() def test_WebPDecode_with_invalid_args(self): """ @@ -139,8 +141,10 @@ class TestFileWebp(PillowTestCase): """ if _webp.HAVE_WEBPANIM: - self.assertRaises(TypeError, _webp.WebPAnimDecoder) - self.assertRaises(TypeError, _webp.WebPDecode) + with pytest.raises(TypeError): + _webp.WebPAnimDecoder() + with pytest.raises(TypeError): + _webp.WebPDecode() def test_no_resource_warning(self): file_path = "Tests/images/hopper.webp" @@ -173,4 +177,4 @@ class TestFileWebp(PillowTestCase): difference = sum( [abs(original_value[i] - reread_value[i]) for i in range(0, 3)] ) - self.assertLess(difference, 5) + assert difference < 5 diff --git a/Tests/test_file_wmf.py b/Tests/test_file_wmf.py index 7a49af91a..1c2c0442b 100644 --- a/Tests/test_file_wmf.py +++ b/Tests/test_file_wmf.py @@ -1,3 +1,4 @@ +import pytest from PIL import Image, WmfImagePlugin from .helper import PillowTestCase, assert_image_similar, hopper @@ -39,7 +40,7 @@ class TestFileWmf(PillowTestCase): im = hopper() tmpfile = self.tempfile("temp.wmf") im.save(tmpfile) - self.assertTrue(handler.methodCalled) + assert handler.methodCalled # Restore the state before this test WmfImagePlugin.register_handler(None) @@ -47,19 +48,19 @@ class TestFileWmf(PillowTestCase): def test_load_dpi_rounding(self): # Round up with Image.open("Tests/images/drawing.emf") as im: - self.assertEqual(im.info["dpi"], 1424) + assert im.info["dpi"] == 1424 # Round down with Image.open("Tests/images/drawing_roundDown.emf") as im: - self.assertEqual(im.info["dpi"], 1426) + assert im.info["dpi"] == 1426 def test_load_set_dpi(self): with Image.open("Tests/images/drawing.wmf") as im: - self.assertEqual(im.size, (82, 82)) + assert im.size == (82, 82) if hasattr(Image.core, "drawwmf"): im.load(144) - self.assertEqual(im.size, (164, 164)) + assert im.size == (164, 164) with Image.open("Tests/images/drawing_wmf_ref_144.png") as expected: assert_image_similar(im, expected, 2.0) @@ -69,4 +70,5 @@ class TestFileWmf(PillowTestCase): for ext in [".wmf", ".emf"]: tmpfile = self.tempfile("temp" + ext) - self.assertRaises(IOError, im.save, tmpfile) + with pytest.raises(IOError): + im.save(tmpfile) diff --git a/Tests/test_font_pcf.py b/Tests/test_font_pcf.py index 358798948..95250e5ee 100644 --- a/Tests/test_font_pcf.py +++ b/Tests/test_font_pcf.py @@ -1,3 +1,4 @@ +import pytest from PIL import FontFile, Image, ImageDraw, ImageFont, PcfFontFile from .helper import ( @@ -17,9 +18,9 @@ class TestFontPcf(PillowTestCase): def save_font(self): with open(fontname, "rb") as test_file: font = PcfFontFile.PcfFontFile(test_file) - self.assertIsInstance(font, FontFile.FontFile) + assert isinstance(font, FontFile.FontFile) # check the number of characters in the font - self.assertEqual(len([_f for _f in font.glyph if _f]), 223) + assert len([_f for _f in font.glyph if _f]) == 223 tempname = self.tempfile("temp.pil") self.addCleanup(self.delete_tempfile, tempname[:-4] + ".pbm") @@ -31,7 +32,7 @@ class TestFontPcf(PillowTestCase): with open(tempname, "rb") as f_loaded: with open("Tests/fonts/10x20.pil", "rb") as f_target: - self.assertEqual(f_loaded.read(), f_target.read()) + assert f_loaded.read() == f_target.read() return tempname def test_sanity(self): @@ -39,7 +40,8 @@ class TestFontPcf(PillowTestCase): def test_invalid_file(self): with open("Tests/images/flower.jpg", "rb") as fp: - self.assertRaises(SyntaxError, PcfFontFile.PcfFontFile, fp) + with pytest.raises(SyntaxError): + PcfFontFile.PcfFontFile(fp) def test_draw(self): tempname = self.save_font() @@ -55,11 +57,11 @@ class TestFontPcf(PillowTestCase): font = ImageFont.load(tempname) for i in range(255): (dx, dy) = font.getsize(chr(i)) - self.assertEqual(dy, 20) - self.assertIn(dx, (0, 10)) + assert dy == 20 + assert dx in (0, 10) for l in range(len(message)): msg = message[: l + 1] - self.assertEqual(font.getsize(msg), (len(msg) * 10, 20)) + assert font.getsize(msg) == (len(msg) * 10, 20) def _test_high_characters(self, message): tempname = self.save_font() diff --git a/Tests/test_image.py b/Tests/test_image.py index c583352b3..55ee1a9fe 100644 --- a/Tests/test_image.py +++ b/Tests/test_image.py @@ -53,66 +53,72 @@ class TestImage(PillowTestCase): "BGR;24", "BGR;32", ]: - with self.assertRaises(ValueError) as e: + with pytest.raises(ValueError) as e: Image.new(mode, (1, 1)) - self.assertEqual(str(e.exception), "unrecognized image mode") + assert str(e.value) == "unrecognized image mode" def test_exception_inheritance(self): - self.assertTrue(issubclass(UnidentifiedImageError, IOError)) + assert issubclass(UnidentifiedImageError, IOError) def test_sanity(self): im = Image.new("L", (100, 100)) - self.assertEqual(repr(im)[:45], " expected {:.4f} " - "for '{}' band" - ).format(average_diff, max_average_diff, band), - ) + msg = "average pixel value difference {:.4f} > expected {:.4f} " + "for '{}' band".format(average_diff, max_average_diff, band) + assert max_average_diff >= average_diff, msg last_diff = [i for i, num in enumerate(ch_hist) if num > 0][-1] - self.assertGreaterEqual( - max_diff, - last_diff, - "max pixel value difference {} > expected {} for '{}' band".format( - last_diff, max_diff, band - ), + assert ( + max_diff >= last_diff + ), "max pixel value difference {} > expected {} for '{}' band".format( + last_diff, max_diff, band ) def test_mode_L(self): diff --git a/Tests/test_image_resample.py b/Tests/test_image_resample.py index e1ca4af7e..7ed6fce07 100644 --- a/Tests/test_image_resample.py +++ b/Tests/test_image_resample.py @@ -1,6 +1,7 @@ import unittest from contextlib import contextmanager +import pytest from PIL import Image, ImageDraw from .helper import PillowTestCase, assert_image_equal, assert_image_similar, hopper @@ -16,7 +17,7 @@ class TestImagingResampleVulnerability(PillowTestCase): (size_too_large, size_normal), (size_normal, size_too_large), ): - with self.assertRaises(MemoryError): + with pytest.raises(MemoryError): # any resampling filter will do here im.im.resize((xsize, ysize), Image.BILINEAR) @@ -26,10 +27,10 @@ class TestImagingResampleVulnerability(PillowTestCase): # Should not crash im.resize((100, 100)) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): im.resize((-100, 100)) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): im.resize((100, -100)) def test_modify_after_resizing(self): @@ -39,7 +40,7 @@ class TestImagingResampleVulnerability(PillowTestCase): # some in-place operation copy.paste("black", (0, 0, im.width // 2, im.height // 2)) # image should be different - self.assertNotEqual(im.tobytes(), copy.tobytes()) + assert im.tobytes() != copy.tobytes() class TestImagingCoreResampleAccuracy(PillowTestCase): @@ -84,7 +85,7 @@ class TestImagingCoreResampleAccuracy(PillowTestCase): message = "\nHave: \n{}\n\nExpected: \n{}".format( self.serialize_image(case), self.serialize_image(sample) ) - self.assertEqual(s_px[x, y], c_px[x, y], message) + assert s_px[x, y] == c_px[x, y], message def serialize_image(self, image): s_px = image.load() @@ -230,7 +231,7 @@ class CoreResampleConsistencyTest(PillowTestCase): for y in range(channel.size[1]): if px[x, y] != color: message = "{} != {} for pixel {}".format(px[x, y], color, (x, y)) - self.assertEqual(px[x, y], color, message) + assert px[x, y] == color, message def test_8u(self): im, color = self.make_case("RGB", (0, 64, 255)) @@ -268,11 +269,10 @@ class CoreResampleAlphaCorrectTest(PillowTestCase): px = i.load() for y in range(i.size[1]): used_colors = {px[x, y][0] for x in range(i.size[0])} - self.assertEqual( - 256, - len(used_colors), - "All colors should present in resized image. " - "Only {} on {} line.".format(len(used_colors), y), + assert 256 == len( + used_colors + ), "All colors should present in resized image. Only {} on {} line.".format( + len(used_colors), y ) @unittest.skip("current implementation isn't precise enough") @@ -311,7 +311,7 @@ class CoreResampleAlphaCorrectTest(PillowTestCase): message = "pixel at ({}, {}) is differ:\n{}\n{}".format( x, y, px[x, y], clean_pixel ) - self.assertEqual(px[x, y][:3], clean_pixel, message) + assert px[x, y][:3] == clean_pixel, message def test_dirty_pixels_rgba(self): case = self.make_dirty_case("RGBA", (255, 255, 0, 128), (0, 0, 255, 0)) @@ -335,7 +335,7 @@ class CoreResamplePassesTest(PillowTestCase): def count(self, diff): count = Image.core.get_stats()["new_count"] yield - self.assertEqual(Image.core.get_stats()["new_count"] - count, diff) + assert Image.core.get_stats()["new_count"] - count == diff def test_horizontal(self): im = hopper("L") @@ -384,7 +384,7 @@ class CoreResampleCoefficientsTest(PillowTestCase): px = i.resize((5, i.size[1]), Image.BICUBIC).load() if px[2, 0] != test_color // 2: - self.assertEqual(test_color // 2, px[2, 0]) + assert test_color // 2 == px[2, 0] def test_nonzero_coefficients(self): # regression test for the wrong coefficients calculation @@ -393,13 +393,13 @@ class CoreResampleCoefficientsTest(PillowTestCase): histogram = im.resize((256, 256), Image.BICUBIC).histogram() # first channel - self.assertEqual(histogram[0x100 * 0 + 0x20], 0x10000) + assert histogram[0x100 * 0 + 0x20] == 0x10000 # second channel - self.assertEqual(histogram[0x100 * 1 + 0x40], 0x10000) + assert histogram[0x100 * 1 + 0x40] == 0x10000 # third channel - self.assertEqual(histogram[0x100 * 2 + 0x60], 0x10000) + assert histogram[0x100 * 2 + 0x60] == 0x10000 # fourth channel - self.assertEqual(histogram[0x100 * 3 + 0xFF], 0x10000) + assert histogram[0x100 * 3 + 0xFF] == 0x10000 class CoreResampleBoxTest(PillowTestCase): @@ -456,7 +456,7 @@ class CoreResampleBoxTest(PillowTestCase): def test_tiles(self): with Image.open("Tests/images/flower.jpg") as im: - self.assertEqual(im.size, (480, 360)) + assert im.size == (480, 360) dst_size = (251, 188) reference = im.resize(dst_size, Image.BICUBIC) @@ -468,7 +468,7 @@ class CoreResampleBoxTest(PillowTestCase): # This test shows advantages of the subpixel resizing # after supersampling (e.g. during JPEG decoding). with Image.open("Tests/images/flower.jpg") as im: - self.assertEqual(im.size, (480, 360)) + assert im.size == (480, 360) dst_size = (48, 36) # Reference is cropped image resized to destination reference = im.crop((0, 0, 473, 353)).resize(dst_size, Image.BICUBIC) @@ -503,7 +503,7 @@ class CoreResampleBoxTest(PillowTestCase): ((40, 50), (10, 20, 50, 70)), ]: res = im.resize(size, Image.LANCZOS, box) - self.assertEqual(res.size, size) + assert res.size == size assert_image_equal(res, im.crop(box), ">>> {} {}".format(size, box)) def test_no_passthrough(self): @@ -517,7 +517,7 @@ class CoreResampleBoxTest(PillowTestCase): ((40, 50), (10.4, 20.4, 50.4, 70.4)), ]: res = im.resize(size, Image.LANCZOS, box) - self.assertEqual(res.size, size) + assert res.size == size with self.assertRaisesRegex(AssertionError, r"difference \d"): # check that the difference at least that much assert_image_similar( @@ -536,7 +536,7 @@ class CoreResampleBoxTest(PillowTestCase): ((40, 50), (10, 20, 50, 90)), ]: res = im.resize(size, flt, box) - self.assertEqual(res.size, size) + assert res.size == size # Borders should be slightly different assert_image_similar( res, @@ -557,7 +557,7 @@ class CoreResampleBoxTest(PillowTestCase): ((40, 50), (20, 10, 90, 60)), ]: res = im.resize(size, flt, box) - self.assertEqual(res.size, size) + assert res.size == size # Borders should be slightly different assert_image_similar( res, diff --git a/Tests/test_image_resize.py b/Tests/test_image_resize.py index 66a82230d..3281836d5 100644 --- a/Tests/test_image_resize.py +++ b/Tests/test_image_resize.py @@ -3,6 +3,7 @@ Tests for resize functionality. """ from itertools import permutations +import pytest from PIL import Image from .helper import PillowTestCase, assert_image_equal, assert_image_similar, hopper @@ -29,26 +30,23 @@ class TestImagingCoreResize(PillowTestCase): ]: # exotic mode im = hopper(mode) r = self.resize(im, (15, 12), Image.NEAREST) - self.assertEqual(r.mode, mode) - self.assertEqual(r.size, (15, 12)) - self.assertEqual(r.im.bands, im.im.bands) + assert r.mode == mode + assert r.size == (15, 12) + assert r.im.bands == im.im.bands def test_convolution_modes(self): - self.assertRaises( - ValueError, self.resize, hopper("1"), (15, 12), Image.BILINEAR - ) - self.assertRaises( - ValueError, self.resize, hopper("P"), (15, 12), Image.BILINEAR - ) - self.assertRaises( - ValueError, self.resize, hopper("I;16"), (15, 12), Image.BILINEAR - ) + with pytest.raises(ValueError): + self.resize(hopper("1"), (15, 12), Image.BILINEAR) + with pytest.raises(ValueError): + self.resize(hopper("P"), (15, 12), Image.BILINEAR) + with pytest.raises(ValueError): + self.resize(hopper("I;16"), (15, 12), Image.BILINEAR) for mode in ["L", "I", "F", "RGB", "RGBA", "CMYK", "YCbCr"]: im = hopper(mode) r = self.resize(im, (15, 12), Image.BILINEAR) - self.assertEqual(r.mode, mode) - self.assertEqual(r.size, (15, 12)) - self.assertEqual(r.im.bands, im.im.bands) + assert r.mode == mode + assert r.size == (15, 12) + assert r.im.bands == im.im.bands def test_reduce_filters(self): for f in [ @@ -60,8 +58,8 @@ class TestImagingCoreResize(PillowTestCase): Image.LANCZOS, ]: r = self.resize(hopper("RGB"), (15, 12), f) - self.assertEqual(r.mode, "RGB") - self.assertEqual(r.size, (15, 12)) + assert r.mode == "RGB" + assert r.size == (15, 12) def test_enlarge_filters(self): for f in [ @@ -73,8 +71,8 @@ class TestImagingCoreResize(PillowTestCase): Image.LANCZOS, ]: r = self.resize(hopper("RGB"), (212, 195), f) - self.assertEqual(r.mode, "RGB") - self.assertEqual(r.size, (212, 195)) + assert r.mode == "RGB" + assert r.size == (212, 195) def test_endianness(self): # Make an image with one colored pixel, in one channel. @@ -128,12 +126,13 @@ class TestImagingCoreResize(PillowTestCase): Image.LANCZOS, ]: r = self.resize(Image.new("RGB", (0, 0), "white"), (212, 195), f) - self.assertEqual(r.mode, "RGB") - self.assertEqual(r.size, (212, 195)) - self.assertEqual(r.getdata()[0], (0, 0, 0)) + assert r.mode == "RGB" + assert r.size == (212, 195) + assert r.getdata()[0] == (0, 0, 0) def test_unknown_filter(self): - self.assertRaises(ValueError, self.resize, hopper(), (10, 10), 9) + with pytest.raises(ValueError): + self.resize(hopper(), (10, 10), 9) class TestReducingGapResize(PillowTestCase): @@ -147,10 +146,10 @@ class TestReducingGapResize(PillowTestCase): im = self.gradients_image.resize((52, 34), Image.BICUBIC) assert_image_equal(ref, im) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): self.gradients_image.resize((52, 34), Image.BICUBIC, reducing_gap=0) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): self.gradients_image.resize((52, 34), Image.BICUBIC, reducing_gap=0.99) def test_reducing_gap_1(self): @@ -164,7 +163,7 @@ class TestReducingGapResize(PillowTestCase): (52, 34), Image.BICUBIC, box=box, reducing_gap=1.0 ) - with self.assertRaises(AssertionError): + with pytest.raises(AssertionError): assert_image_equal(ref, im) assert_image_similar(ref, im, epsilon) @@ -180,7 +179,7 @@ class TestReducingGapResize(PillowTestCase): (52, 34), Image.BICUBIC, box=box, reducing_gap=2.0 ) - with self.assertRaises(AssertionError): + with pytest.raises(AssertionError): assert_image_equal(ref, im) assert_image_similar(ref, im, epsilon) @@ -196,7 +195,7 @@ class TestReducingGapResize(PillowTestCase): (52, 34), Image.BICUBIC, box=box, reducing_gap=3.0 ) - with self.assertRaises(AssertionError): + with pytest.raises(AssertionError): assert_image_equal(ref, im) assert_image_similar(ref, im, epsilon) @@ -227,8 +226,8 @@ class TestImageResize(PillowTestCase): def test_resize(self): def resize(mode, size): out = hopper(mode).resize(size) - self.assertEqual(out.mode, mode) - self.assertEqual(out.size, size) + assert out.mode == mode + assert out.size == size for mode in "1", "P", "L", "RGB", "I", "F": resize(mode, (112, 103)) @@ -236,13 +235,14 @@ class TestImageResize(PillowTestCase): # Test unknown resampling filter with hopper() as im: - self.assertRaises(ValueError, im.resize, (10, 10), "unknown") + with pytest.raises(ValueError): + im.resize((10, 10), "unknown") def test_default_filter(self): for mode in "L", "RGB", "I", "F": im = hopper(mode) - self.assertEqual(im.resize((20, 20), Image.BICUBIC), im.resize((20, 20))) + assert im.resize((20, 20), Image.BICUBIC) == im.resize((20, 20)) for mode in "1", "P": im = hopper(mode) - self.assertEqual(im.resize((20, 20), Image.NEAREST), im.resize((20, 20))) + assert im.resize((20, 20), Image.NEAREST) == im.resize((20, 20)) diff --git a/Tests/test_image_split.py b/Tests/test_image_split.py index 80a531103..207d5f925 100644 --- a/Tests/test_image_split.py +++ b/Tests/test_image_split.py @@ -9,25 +9,25 @@ class TestImageSplit(PillowTestCase): layers = hopper(mode).split() return [(i.mode, i.size[0], i.size[1]) for i in layers] - self.assertEqual(split("1"), [("1", 128, 128)]) - self.assertEqual(split("L"), [("L", 128, 128)]) - self.assertEqual(split("I"), [("I", 128, 128)]) - self.assertEqual(split("F"), [("F", 128, 128)]) - self.assertEqual(split("P"), [("P", 128, 128)]) - self.assertEqual( - split("RGB"), [("L", 128, 128), ("L", 128, 128), ("L", 128, 128)] - ) - self.assertEqual( - split("RGBA"), - [("L", 128, 128), ("L", 128, 128), ("L", 128, 128), ("L", 128, 128)], - ) - self.assertEqual( - split("CMYK"), - [("L", 128, 128), ("L", 128, 128), ("L", 128, 128), ("L", 128, 128)], - ) - self.assertEqual( - split("YCbCr"), [("L", 128, 128), ("L", 128, 128), ("L", 128, 128)] - ) + assert split("1") == [("1", 128, 128)] + assert split("L") == [("L", 128, 128)] + assert split("I") == [("I", 128, 128)] + assert split("F") == [("F", 128, 128)] + assert split("P") == [("P", 128, 128)] + assert split("RGB") == [("L", 128, 128), ("L", 128, 128), ("L", 128, 128)] + assert split("RGBA") == [ + ("L", 128, 128), + ("L", 128, 128), + ("L", 128, 128), + ("L", 128, 128), + ] + assert split("CMYK") == [ + ("L", 128, 128), + ("L", 128, 128), + ("L", 128, 128), + ("L", 128, 128), + ] + assert split("YCbCr") == [("L", 128, 128), ("L", 128, 128), ("L", 128, 128)] def test_split_merge(self): def split_merge(mode): @@ -54,9 +54,9 @@ class TestImageSplit(PillowTestCase): with Image.open(test_file) as im: return len(im.split()) - self.assertEqual(split_open("1"), 1) - self.assertEqual(split_open("L"), 1) - self.assertEqual(split_open("P"), 1) - self.assertEqual(split_open("RGB"), 3) + assert split_open("1") == 1 + assert split_open("L") == 1 + assert split_open("P") == 1 + assert split_open("RGB") == 3 if features.check("zlib"): - self.assertEqual(split_open("RGBA"), 4) + assert split_open("RGBA") == 4 diff --git a/Tests/test_image_transform.py b/Tests/test_image_transform.py index 7575fd1d8..c833370a5 100644 --- a/Tests/test_image_transform.py +++ b/Tests/test_image_transform.py @@ -1,5 +1,6 @@ import math +import pytest from PIL import Image, ImageTransform from .helper import PillowTestCase, assert_image_equal, assert_image_similar, hopper @@ -24,11 +25,11 @@ class TestImageTransform(PillowTestCase): comment = b"File written by Adobe Photoshop\xa8 4.0" with Image.open("Tests/images/hopper.gif") as im: - self.assertEqual(im.info["comment"], comment) + assert im.info["comment"] == comment transform = ImageTransform.ExtentTransform((0, 0, 0, 0)) new_im = im.transform((100, 100), transform) - self.assertEqual(new_im.info["comment"], comment) + assert new_im.info["comment"] == comment def test_extent(self): im = hopper("RGB") @@ -79,7 +80,7 @@ class TestImageTransform(PillowTestCase): fillcolor="red", ) - self.assertEqual(transformed.getpixel((w - 1, h - 1)), pixel) + assert transformed.getpixel((w - 1, h - 1)) == pixel def test_mesh(self): # this should be a checkerboard of halfsized hoppers in ul, lr @@ -126,7 +127,7 @@ class TestImageTransform(PillowTestCase): im_background.paste(im, (0, 0), im) hist = im_background.histogram() - self.assertEqual(40 * 10, hist[-1]) + assert 40 * 10 == hist[-1] def test_alpha_premult_resize(self): def op(im, sz): @@ -165,20 +166,15 @@ class TestImageTransform(PillowTestCase): def test_missing_method_data(self): with hopper() as im: - self.assertRaises(ValueError, im.transform, (100, 100), None) + with pytest.raises(ValueError): + im.transform((100, 100), None) def test_unknown_resampling_filter(self): with hopper() as im: (w, h) = im.size for resample in (Image.BOX, "unknown"): - self.assertRaises( - ValueError, - im.transform, - (100, 100), - Image.EXTENT, - (0, 0, w, h), - resample, - ) + with pytest.raises(ValueError): + im.transform((100, 100), Image.EXTENT, (0, 0, w, h), resample) class TestImageTransformAffine(PillowTestCase): diff --git a/Tests/test_imagefile.py b/Tests/test_imagefile.py index 18771fd41..c3086700a 100644 --- a/Tests/test_imagefile.py +++ b/Tests/test_imagefile.py @@ -1,5 +1,6 @@ from io import BytesIO +import pytest from PIL import EpsImagePlugin, Image, ImageFile, features from .helper import ( @@ -71,14 +72,15 @@ class TestImageFile(PillowTestCase): im1, im2 = roundtrip("JPEG") # lossy compression assert_image(im1, im2.mode, im2.size) - self.assertRaises(IOError, roundtrip, "PDF") + with pytest.raises(IOError): + roundtrip("PDF") def test_ico(self): with open("Tests/images/python.ico", "rb") as f: data = f.read() with ImageFile.Parser() as p: p.feed(data) - self.assertEqual((48, 48), p.image.size) + assert (48, 48) == p.image.size @skip_unless_feature("zlib") def test_safeblock(self): @@ -93,10 +95,11 @@ class TestImageFile(PillowTestCase): assert_image_equal(im1, im2) def test_raise_ioerror(self): - self.assertRaises(IOError, ImageFile.raise_ioerror, 1) + with pytest.raises(IOError): + ImageFile.raise_ioerror(1) def test_raise_typeerror(self): - with self.assertRaises(TypeError): + with pytest.raises(TypeError): parser = ImageFile.Parser() parser.feed(1) @@ -105,17 +108,17 @@ class TestImageFile(PillowTestCase): input = f.read() p = ImageFile.Parser() p.feed(input) - with self.assertRaises(IOError): + with pytest.raises(IOError): p.close() @skip_unless_feature("zlib") def test_truncated_with_errors(self): with Image.open("Tests/images/truncated_image.png") as im: - with self.assertRaises(IOError): + with pytest.raises(IOError): im.load() # Test that the error is raised if loaded a second time - with self.assertRaises(IOError): + with pytest.raises(IOError): im.load() @skip_unless_feature("zlib") @@ -130,7 +133,7 @@ class TestImageFile(PillowTestCase): @skip_unless_feature("zlib") def test_broken_datastream_with_errors(self): with Image.open("Tests/images/broken_data_stream.png") as im: - with self.assertRaises(IOError): + with pytest.raises(IOError): im.load() @skip_unless_feature("zlib") @@ -179,12 +182,13 @@ class TestPyDecoder(PillowTestCase): im.load() - self.assertEqual(d.state.xoff, xoff) - self.assertEqual(d.state.yoff, yoff) - self.assertEqual(d.state.xsize, xsize) - self.assertEqual(d.state.ysize, ysize) + assert d.state.xoff == xoff + assert d.state.yoff == yoff + assert d.state.xsize == xsize + assert d.state.ysize == ysize - self.assertRaises(ValueError, d.set_as_raw, b"\x00") + with pytest.raises(ValueError): + d.set_as_raw(b"\x00") def test_extents_none(self): buf = BytesIO(b"\x00" * 255) @@ -195,10 +199,10 @@ class TestPyDecoder(PillowTestCase): im.load() - self.assertEqual(d.state.xoff, 0) - self.assertEqual(d.state.yoff, 0) - self.assertEqual(d.state.xsize, 200) - self.assertEqual(d.state.ysize, 200) + assert d.state.xoff == 0 + assert d.state.yoff == 0 + assert d.state.xsize == 200 + assert d.state.ysize == 200 def test_negsize(self): buf = BytesIO(b"\x00" * 255) @@ -207,10 +211,12 @@ class TestPyDecoder(PillowTestCase): im.tile = [("MOCK", (xoff, yoff, -10, yoff + ysize), 32, None)] self.get_decoder() - self.assertRaises(ValueError, im.load) + with pytest.raises(ValueError): + im.load() im.tile = [("MOCK", (xoff, yoff, xoff + xsize, -10), 32, None)] - self.assertRaises(ValueError, im.load) + with pytest.raises(ValueError): + im.load() def test_oversize(self): buf = BytesIO(b"\x00" * 255) @@ -219,25 +225,27 @@ class TestPyDecoder(PillowTestCase): im.tile = [("MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 32, None)] self.get_decoder() - self.assertRaises(ValueError, im.load) + with pytest.raises(ValueError): + im.load() im.tile = [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 32, None)] - self.assertRaises(ValueError, im.load) + with pytest.raises(ValueError): + im.load() def test_no_format(self): buf = BytesIO(b"\x00" * 255) im = MockImageFile(buf) - self.assertIsNone(im.format) - self.assertIsNone(im.get_format_mimetype()) + assert im.format is None + assert im.get_format_mimetype() is None def test_exif_jpeg(self): with Image.open("Tests/images/exif-72dpi-int.jpg") as im: # Little endian exif = im.getexif() - self.assertNotIn(258, exif) - self.assertIn(40960, exif) - self.assertEqual(exif[40963], 450) - self.assertEqual(exif[11], "gThumb 3.0.1") + assert 258 not in exif + assert 40960 in exif + assert exif[40963] == 450 + assert exif[11] == "gThumb 3.0.1" out = self.tempfile("temp.jpg") exif[258] = 8 @@ -247,17 +255,17 @@ class TestPyDecoder(PillowTestCase): im.save(out, exif=exif) with Image.open(out) as reloaded: reloaded_exif = reloaded.getexif() - self.assertEqual(reloaded_exif[258], 8) - self.assertNotIn(40960, exif) - self.assertEqual(reloaded_exif[40963], 455) - self.assertEqual(exif[11], "Pillow test") + assert reloaded_exif[258] == 8 + assert 40960 not in exif + assert reloaded_exif[40963] == 455 + assert exif[11] == "Pillow test" with Image.open("Tests/images/no-dpi-in-exif.jpg") as im: # Big endian exif = im.getexif() - self.assertNotIn(258, exif) - self.assertIn(40962, exif) - self.assertEqual(exif[40963], 200) - self.assertEqual(exif[305], "Adobe Photoshop CC 2017 (Macintosh)") + assert 258 not in exif + assert 40962 in exif + assert exif[40963] == 200 + assert exif[305] == "Adobe Photoshop CC 2017 (Macintosh)" out = self.tempfile("temp.jpg") exif[258] = 8 @@ -267,17 +275,17 @@ class TestPyDecoder(PillowTestCase): im.save(out, exif=exif) with Image.open(out) as reloaded: reloaded_exif = reloaded.getexif() - self.assertEqual(reloaded_exif[258], 8) - self.assertNotIn(40960, exif) - self.assertEqual(reloaded_exif[40963], 455) - self.assertEqual(exif[305], "Pillow test") + assert reloaded_exif[258] == 8 + assert 40960 not in exif + assert reloaded_exif[40963] == 455 + assert exif[305] == "Pillow test" @skip_unless_feature("webp") @skip_unless_feature("webp_anim") def test_exif_webp(self): with Image.open("Tests/images/hopper.webp") as im: exif = im.getexif() - self.assertEqual(exif, {}) + assert exif == {} out = self.tempfile("temp.webp") exif[258] = 8 @@ -287,9 +295,9 @@ class TestPyDecoder(PillowTestCase): def check_exif(): with Image.open(out) as reloaded: reloaded_exif = reloaded.getexif() - self.assertEqual(reloaded_exif[258], 8) - self.assertEqual(reloaded_exif[40963], 455) - self.assertEqual(exif[305], "Pillow test") + assert reloaded_exif[258] == 8 + assert reloaded_exif[40963] == 455 + assert exif[305] == "Pillow test" im.save(out, exif=exif) check_exif() @@ -299,7 +307,7 @@ class TestPyDecoder(PillowTestCase): def test_exif_png(self): with Image.open("Tests/images/exif.png") as im: exif = im.getexif() - self.assertEqual(exif, {274: 1}) + assert exif == {274: 1} out = self.tempfile("temp.png") exif[258] = 8 @@ -310,11 +318,14 @@ class TestPyDecoder(PillowTestCase): with Image.open(out) as reloaded: reloaded_exif = reloaded.getexif() - self.assertEqual(reloaded_exif, {258: 8, 40963: 455, 305: "Pillow test"}) + assert reloaded_exif == {258: 8, 40963: 455, 305: "Pillow test"} def test_exif_interop(self): with Image.open("Tests/images/flower.jpg") as im: exif = im.getexif() - self.assertEqual( - exif.get_ifd(0xA005), {1: "R98", 2: b"0100", 4097: 2272, 4098: 1704} - ) + assert exif.get_ifd(0xA005) == { + 1: "R98", + 2: b"0100", + 4097: 2272, + 4098: 1704, + } diff --git a/Tests/test_imagefont.py b/Tests/test_imagefont.py index 93adc0911..29da67f08 100644 --- a/Tests/test_imagefont.py +++ b/Tests/test_imagefont.py @@ -7,6 +7,7 @@ import unittest from io import BytesIO from unittest import mock +import pytest from PIL import Image, ImageDraw, ImageFont from .helper import ( @@ -69,19 +70,19 @@ class TestImageFont(PillowTestCase): def test_font_properties(self): ttf = self.get_font() - self.assertEqual(ttf.path, FONT_PATH) - self.assertEqual(ttf.size, FONT_SIZE) + assert ttf.path == FONT_PATH + assert ttf.size == FONT_SIZE ttf_copy = ttf.font_variant() - self.assertEqual(ttf_copy.path, FONT_PATH) - self.assertEqual(ttf_copy.size, FONT_SIZE) + assert ttf_copy.path == FONT_PATH + assert ttf_copy.size == FONT_SIZE ttf_copy = ttf.font_variant(size=FONT_SIZE + 1) - self.assertEqual(ttf_copy.size, FONT_SIZE + 1) + assert ttf_copy.size == FONT_SIZE + 1 second_font_path = "Tests/fonts/DejaVuSans.ttf" ttf_copy = ttf.font_variant(font=second_font_path) - self.assertEqual(ttf_copy.path, second_font_path) + assert ttf_copy.path == second_font_path def test_font_with_name(self): self.get_font() @@ -100,7 +101,8 @@ class TestImageFont(PillowTestCase): # Usage note: making two fonts from the same buffer fails. # shared_bytes = self._font_as_bytes() # self._render(shared_bytes) - # self.assertRaises(Exception, _render, shared_bytes) + # with pytest.raises(Exception): + # _render(shared_bytes) def test_font_with_open_file(self): with open(FONT_PATH, "rb") as f: @@ -126,7 +128,7 @@ class TestImageFont(PillowTestCase): finally: ImageFont.core.HAVE_RAQM = have_raqm - self.assertEqual(ttf.layout_engine, ImageFont.LAYOUT_BASIC) + assert ttf.layout_engine == ImageFont.LAYOUT_BASIC def _render(self, font): txt = "Hello World!" @@ -222,14 +224,8 @@ class TestImageFont(PillowTestCase): ttf = self.get_font() # Act/Assert - self.assertRaises( - ValueError, - draw.multiline_text, - (0, 0), - TEST_TEXT, - font=ttf, - align="unknown", - ) + with pytest.raises(ValueError): + draw.multiline_text((0, 0), TEST_TEXT, font=ttf, align="unknown") def test_draw_align(self): im = Image.new("RGB", (300, 100), "white") @@ -244,14 +240,13 @@ class TestImageFont(PillowTestCase): draw = ImageDraw.Draw(im) # Test that textsize() correctly connects to multiline_textsize() - self.assertEqual( - draw.textsize(TEST_TEXT, font=ttf), - draw.multiline_textsize(TEST_TEXT, font=ttf), + assert draw.textsize(TEST_TEXT, font=ttf) == draw.multiline_textsize( + TEST_TEXT, font=ttf ) # Test that multiline_textsize corresponds to ImageFont.textsize() # for single line text - self.assertEqual(ttf.getsize("A"), draw.multiline_textsize("A", font=ttf)) + assert ttf.getsize("A") == draw.multiline_textsize("A", font=ttf) # Test that textsize() can pass on additional arguments # to multiline_textsize() @@ -263,9 +258,9 @@ class TestImageFont(PillowTestCase): im = Image.new(mode="RGB", size=(300, 100)) draw = ImageDraw.Draw(im) - self.assertEqual( - draw.textsize("longest line", font=ttf)[0], - draw.multiline_textsize("longest line\nline", font=ttf)[0], + assert ( + draw.textsize("longest line", font=ttf)[0] + == draw.multiline_textsize("longest line\nline", font=ttf)[0] ) def test_multiline_spacing(self): @@ -299,8 +294,8 @@ class TestImageFont(PillowTestCase): box_size_b = draw.textsize(word) # Check (w,h) of box a is (h,w) of box b - self.assertEqual(box_size_a[0], box_size_b[1]) - self.assertEqual(box_size_a[1], box_size_b[0]) + assert box_size_a[0] == box_size_b[1] + assert box_size_a[1] == box_size_b[0] def test_unrotated_transposed_font(self): img_grey = Image.new("L", (100, 100)) @@ -320,7 +315,7 @@ class TestImageFont(PillowTestCase): box_size_b = draw.textsize(word) # Check boxes a and b are same size - self.assertEqual(box_size_a, box_size_b) + assert box_size_a == box_size_b def test_rotated_transposed_font_get_mask(self): # Arrange @@ -333,7 +328,7 @@ class TestImageFont(PillowTestCase): mask = transposed_font.getmask(text) # Assert - self.assertEqual(mask.size, (13, 108)) + assert mask.size == (13, 108) def test_unrotated_transposed_font_get_mask(self): # Arrange @@ -346,7 +341,7 @@ class TestImageFont(PillowTestCase): mask = transposed_font.getmask(text) # Assert - self.assertEqual(mask.size, (108, 13)) + assert mask.size == (108, 13) def test_free_type_font_get_name(self): # Arrange @@ -356,7 +351,7 @@ class TestImageFont(PillowTestCase): name = font.getname() # Assert - self.assertEqual(("FreeMono", "Regular"), name) + assert ("FreeMono", "Regular") == name def test_free_type_font_get_metrics(self): # Arrange @@ -366,9 +361,9 @@ class TestImageFont(PillowTestCase): ascent, descent = font.getmetrics() # Assert - self.assertIsInstance(ascent, int) - self.assertIsInstance(descent, int) - self.assertEqual((ascent, descent), (16, 4)) # too exact check? + assert isinstance(ascent, int) + assert isinstance(descent, int) + assert (ascent, descent) == (16, 4) # too exact check? def test_free_type_font_get_offset(self): # Arrange @@ -379,7 +374,7 @@ class TestImageFont(PillowTestCase): offset = font.getoffset(text) # Assert - self.assertEqual(offset, (0, 3)) + assert offset == (0, 3) def test_free_type_font_get_mask(self): # Arrange @@ -390,19 +385,22 @@ class TestImageFont(PillowTestCase): mask = font.getmask(text) # Assert - self.assertEqual(mask.size, (108, 13)) + assert mask.size == (108, 13) def test_load_path_not_found(self): # Arrange filename = "somefilenamethatdoesntexist.ttf" # Act/Assert - self.assertRaises(IOError, ImageFont.load_path, filename) - self.assertRaises(IOError, ImageFont.truetype, filename) + with pytest.raises(IOError): + ImageFont.load_path(filename) + with pytest.raises(IOError): + ImageFont.truetype(filename) def test_load_non_font_bytes(self): with open("Tests/images/hopper.jpg", "rb") as f: - self.assertRaises(IOError, ImageFont.truetype, f) + with pytest.raises(IOError): + ImageFont.truetype(f) def test_default_font(self): # Arrange @@ -424,7 +422,7 @@ class TestImageFont(PillowTestCase): # issue #2614 font = self.get_font() # should not crash. - self.assertEqual((0, 0), font.getsize("")) + assert (0, 0) == font.getsize("") def test_render_empty(self): # issue 2666 @@ -440,7 +438,7 @@ class TestImageFont(PillowTestCase): # should not segfault, should return UnicodeDecodeError # issue #2826 font = ImageFont.load_default() - with self.assertRaises(UnicodeEncodeError): + with pytest.raises(UnicodeEncodeError): font.getsize("’") @unittest.skipIf(is_pypy(), "failing on PyPy") @@ -478,7 +476,7 @@ class TestImageFont(PillowTestCase): font = ImageFont.truetype(fontname) # Make sure it's loaded name = font.getname() - self.assertEqual(("FreeMono", "Regular"), name) + assert ("FreeMono", "Regular") == name @unittest.skipIf(is_win32(), "requires Unix or macOS") def test_find_linux_font(self): @@ -561,24 +559,24 @@ class TestImageFont(PillowTestCase): t = self.get_font() # Act / Assert - self.assertEqual(t.getmetrics(), (16, 4)) - self.assertEqual(t.font.ascent, 16) - self.assertEqual(t.font.descent, 4) - self.assertEqual(t.font.height, 20) - self.assertEqual(t.font.x_ppem, 20) - self.assertEqual(t.font.y_ppem, 20) - self.assertEqual(t.font.glyphs, 4177) - self.assertEqual(t.getsize("A"), (12, 16)) - self.assertEqual(t.getsize("AB"), (24, 16)) - self.assertEqual(t.getsize("M"), self.metrics["getters"]) - self.assertEqual(t.getsize("y"), (12, 20)) - self.assertEqual(t.getsize("a"), (12, 16)) - self.assertEqual(t.getsize_multiline("A"), (12, 16)) - self.assertEqual(t.getsize_multiline("AB"), (24, 16)) - self.assertEqual(t.getsize_multiline("a"), (12, 16)) - self.assertEqual(t.getsize_multiline("ABC\n"), (36, 36)) - self.assertEqual(t.getsize_multiline("ABC\nA"), (36, 36)) - self.assertEqual(t.getsize_multiline("ABC\nAaaa"), (48, 36)) + assert t.getmetrics() == (16, 4) + assert t.font.ascent == 16 + assert t.font.descent == 4 + assert t.font.height == 20 + assert t.font.x_ppem == 20 + assert t.font.y_ppem == 20 + assert t.font.glyphs == 4177 + assert t.getsize("A") == (12, 16) + assert t.getsize("AB") == (24, 16) + assert t.getsize("M") == self.metrics["getters"] + assert t.getsize("y") == (12, 20) + assert t.getsize("a") == (12, 16) + assert t.getsize_multiline("A") == (12, 16) + assert t.getsize_multiline("AB") == (24, 16) + assert t.getsize_multiline("a") == (12, 16) + assert t.getsize_multiline("ABC\n") == (36, 36) + assert t.getsize_multiline("ABC\nA") == (36, 36) + assert t.getsize_multiline("ABC\nAaaa") == (48, 36) def test_getsize_stroke(self): # Arrange @@ -586,13 +584,13 @@ class TestImageFont(PillowTestCase): # Act / Assert for stroke_width in [0, 2]: - self.assertEqual( - t.getsize("A", stroke_width=stroke_width), - (12 + stroke_width * 2, 16 + stroke_width * 2), + assert t.getsize("A", stroke_width=stroke_width) == ( + 12 + stroke_width * 2, + 16 + stroke_width * 2, ) - self.assertEqual( - t.getsize_multiline("ABC\nAaaa", stroke_width=stroke_width), - (48 + stroke_width * 2, 36 + stroke_width * 4), + assert t.getsize_multiline("ABC\nAaaa", stroke_width=stroke_width) == ( + 48 + stroke_width * 2, + 36 + stroke_width * 4, ) def test_complex_font_settings(self): @@ -600,81 +598,80 @@ class TestImageFont(PillowTestCase): t = self.get_font() # Act / Assert if t.layout_engine == ImageFont.LAYOUT_BASIC: - self.assertRaises(KeyError, t.getmask, "абвг", direction="rtl") - self.assertRaises(KeyError, t.getmask, "абвг", features=["-kern"]) - self.assertRaises(KeyError, t.getmask, "абвг", language="sr") + with pytest.raises(KeyError): + t.getmask("абвг", direction="rtl") + with pytest.raises(KeyError): + t.getmask("абвг", features=["-kern"]) + with pytest.raises(KeyError): + t.getmask("абвг", language="sr") def test_variation_get(self): font = self.get_font() freetype = distutils.version.StrictVersion(ImageFont.core.freetype2_version) if freetype < "2.9.1": - self.assertRaises(NotImplementedError, font.get_variation_names) - self.assertRaises(NotImplementedError, font.get_variation_axes) + with pytest.raises(NotImplementedError): + font.get_variation_names() + with pytest.raises(NotImplementedError): + font.get_variation_axes() return - self.assertRaises(IOError, font.get_variation_names) - self.assertRaises(IOError, font.get_variation_axes) + with pytest.raises(IOError): + font.get_variation_names() + with pytest.raises(IOError): + font.get_variation_axes() font = ImageFont.truetype("Tests/fonts/AdobeVFPrototype.ttf") - self.assertEqual( - font.get_variation_names(), - [ - b"ExtraLight", - b"Light", - b"Regular", - b"Semibold", - b"Bold", - b"Black", - b"Black Medium Contrast", - b"Black High Contrast", - b"Default", - ], - ) - self.assertEqual( - font.get_variation_axes(), - [ - {"name": b"Weight", "minimum": 200, "maximum": 900, "default": 389}, - {"name": b"Contrast", "minimum": 0, "maximum": 100, "default": 0}, - ], - ) + assert font.get_variation_names(), [ + b"ExtraLight", + b"Light", + b"Regular", + b"Semibold", + b"Bold", + b"Black", + b"Black Medium Contrast", + b"Black High Contrast", + b"Default", + ] + assert font.get_variation_axes() == [ + {"name": b"Weight", "minimum": 200, "maximum": 900, "default": 389}, + {"name": b"Contrast", "minimum": 0, "maximum": 100, "default": 0}, + ] font = ImageFont.truetype("Tests/fonts/TINY5x3GX.ttf") - self.assertEqual( - font.get_variation_names(), - [ - b"20", - b"40", - b"60", - b"80", - b"100", - b"120", - b"140", - b"160", - b"180", - b"200", - b"220", - b"240", - b"260", - b"280", - b"300", - b"Regular", - ], - ) - self.assertEqual( - font.get_variation_axes(), - [{"name": b"Size", "minimum": 0, "maximum": 300, "default": 0}], - ) + assert font.get_variation_names() == [ + b"20", + b"40", + b"60", + b"80", + b"100", + b"120", + b"140", + b"160", + b"180", + b"200", + b"220", + b"240", + b"260", + b"280", + b"300", + b"Regular", + ] + assert font.get_variation_axes() == [ + {"name": b"Size", "minimum": 0, "maximum": 300, "default": 0} + ] def test_variation_set_by_name(self): font = self.get_font() freetype = distutils.version.StrictVersion(ImageFont.core.freetype2_version) if freetype < "2.9.1": - self.assertRaises(NotImplementedError, font.set_variation_by_name, "Bold") + with pytest.raises(NotImplementedError): + font.set_variation_by_name("Bold") return - self.assertRaises(IOError, font.set_variation_by_name, "Bold") + with pytest.raises(IOError): + font.set_variation_by_name("Bold") def _check_text(font, path, epsilon): im = Image.new("RGB", (100, 75), "white") @@ -701,10 +698,12 @@ class TestImageFont(PillowTestCase): freetype = distutils.version.StrictVersion(ImageFont.core.freetype2_version) if freetype < "2.9.1": - self.assertRaises(NotImplementedError, font.set_variation_by_axes, [100]) + with pytest.raises(NotImplementedError): + font.set_variation_by_axes([100]) return - self.assertRaises(IOError, font.set_variation_by_axes, [500, 50]) + with pytest.raises(IOError): + font.set_variation_by_axes([500, 50]) def _check_text(font, path, epsilon): im = Image.new("RGB", (100, 75), "white") diff --git a/Tests/test_imagefontctl.py b/Tests/test_imagefontctl.py index 8f619b9f9..de1aa41f3 100644 --- a/Tests/test_imagefontctl.py +++ b/Tests/test_imagefontctl.py @@ -140,7 +140,7 @@ class TestImagecomplextext(PillowTestCase): assert_image_similar(im, target_img, 0.5) liga_size = ttf.getsize("fi", features=["-liga"]) - self.assertEqual(liga_size, (13, 19)) + assert liga_size == (13, 19) def test_kerning_features(self): ttf = ImageFont.truetype(FONT_PATH, FONT_SIZE) diff --git a/Tests/test_imagegrab.py b/Tests/test_imagegrab.py index efa2b54b9..ffefd1acb 100644 --- a/Tests/test_imagegrab.py +++ b/Tests/test_imagegrab.py @@ -59,7 +59,7 @@ class TestImageGrabImport(PillowTestCase): # Assert if sys.platform in ["win32", "darwin"]: - self.assertIsNone(exception) + assert exception is None else: - self.assertIsInstance(exception, ImportError) - self.assertEqual(str(exception), "ImageGrab is macOS and Windows only") + assert isinstance(exception, ImportError) + assert str(exception) == "ImageGrab is macOS and Windows only" diff --git a/Tests/test_imagemorph.py b/Tests/test_imagemorph.py index db9e7b647..5191f99f2 100644 --- a/Tests/test_imagemorph.py +++ b/Tests/test_imagemorph.py @@ -1,4 +1,5 @@ # Test the ImageMorphology functionality +import pytest from PIL import Image, ImageMorph, _imagingmorph from .helper import PillowTestCase, assert_image_equal, hopper @@ -45,10 +46,10 @@ class MorphTests(PillowTestCase): return self.img_to_string(self.string_to_img(im)) def assert_img_equal(self, A, B): - self.assertEqual(self.img_to_string(A), self.img_to_string(B)) + assert self.img_to_string(A) == self.img_to_string(B) def assert_img_equal_img_string(self, A, Bstring): - self.assertEqual(self.img_to_string(A), self.img_string_normalize(Bstring)) + assert self.img_to_string(A) == self.img_string_normalize(Bstring) def test_str_to_img(self): with Image.open("Tests/images/morph_a.png") as im: @@ -65,30 +66,30 @@ class MorphTests(PillowTestCase): def test_lut(self): for op in ("corner", "dilation4", "dilation8", "erosion4", "erosion8", "edge"): lb = ImageMorph.LutBuilder(op_name=op) - self.assertIsNone(lb.get_lut()) + assert lb.get_lut() is None lut = lb.build_lut() with open("Tests/images/%s.lut" % op, "rb") as f: - self.assertEqual(lut, bytearray(f.read())) + assert lut == bytearray(f.read()) def test_no_operator_loaded(self): mop = ImageMorph.MorphOp() - with self.assertRaises(Exception) as e: + with pytest.raises(Exception) as e: mop.apply(None) - self.assertEqual(str(e.exception), "No operator loaded") - with self.assertRaises(Exception) as e: + assert str(e.value) == "No operator loaded" + with pytest.raises(Exception) as e: mop.match(None) - self.assertEqual(str(e.exception), "No operator loaded") - with self.assertRaises(Exception) as e: + assert str(e.value) == "No operator loaded" + with pytest.raises(Exception) as e: mop.save_lut(None) - self.assertEqual(str(e.exception), "No operator loaded") + assert str(e.value) == "No operator loaded" # Test the named patterns def test_erosion8(self): # erosion8 mop = ImageMorph.MorphOp(op_name="erosion8") count, Aout = mop.apply(self.A) - self.assertEqual(count, 8) + assert count == 8 self.assert_img_equal_img_string( Aout, """ @@ -106,7 +107,7 @@ class MorphTests(PillowTestCase): # dialation8 mop = ImageMorph.MorphOp(op_name="dilation8") count, Aout = mop.apply(self.A) - self.assertEqual(count, 16) + assert count == 16 self.assert_img_equal_img_string( Aout, """ @@ -124,7 +125,7 @@ class MorphTests(PillowTestCase): # erosion4 mop = ImageMorph.MorphOp(op_name="dilation4") count, Aout = mop.apply(self.A) - self.assertEqual(count, 12) + assert count == 12 self.assert_img_equal_img_string( Aout, """ @@ -142,7 +143,7 @@ class MorphTests(PillowTestCase): # edge mop = ImageMorph.MorphOp(op_name="edge") count, Aout = mop.apply(self.A) - self.assertEqual(count, 1) + assert count == 1 self.assert_img_equal_img_string( Aout, """ @@ -160,7 +161,7 @@ class MorphTests(PillowTestCase): # Create a corner detector pattern mop = ImageMorph.MorphOp(patterns=["1:(... ... ...)->0", "4:(00. 01. ...)->1"]) count, Aout = mop.apply(self.A) - self.assertEqual(count, 5) + assert count == 5 self.assert_img_equal_img_string( Aout, """ @@ -176,18 +177,18 @@ class MorphTests(PillowTestCase): # Test the coordinate counting with the same operator coords = mop.match(self.A) - self.assertEqual(len(coords), 4) - self.assertEqual(tuple(coords), ((2, 2), (4, 2), (2, 4), (4, 4))) + assert len(coords) == 4 + assert tuple(coords) == ((2, 2), (4, 2), (2, 4), (4, 4)) coords = mop.get_on_pixels(Aout) - self.assertEqual(len(coords), 4) - self.assertEqual(tuple(coords), ((2, 2), (4, 2), (2, 4), (4, 4))) + assert len(coords) == 4 + assert tuple(coords) == ((2, 2), (4, 2), (2, 4), (4, 4)) def test_mirroring(self): # Test 'M' for mirroring mop = ImageMorph.MorphOp(patterns=["1:(... ... ...)->0", "M:(00. 01. ...)->1"]) count, Aout = mop.apply(self.A) - self.assertEqual(count, 7) + assert count == 7 self.assert_img_equal_img_string( Aout, """ @@ -205,7 +206,7 @@ class MorphTests(PillowTestCase): # Test 'N' for negate mop = ImageMorph.MorphOp(patterns=["1:(... ... ...)->0", "N:(00. 01. ...)->1"]) count, Aout = mop.apply(self.A) - self.assertEqual(count, 8) + assert count == 8 self.assert_img_equal_img_string( Aout, """ @@ -223,44 +224,36 @@ class MorphTests(PillowTestCase): im = hopper("RGB") mop = ImageMorph.MorphOp(op_name="erosion8") - with self.assertRaises(Exception) as e: + with pytest.raises(Exception) as e: mop.apply(im) - self.assertEqual( - str(e.exception), "Image must be binary, meaning it must use mode L" - ) - with self.assertRaises(Exception) as e: + assert str(e.value) == "Image must be binary, meaning it must use mode L" + with pytest.raises(Exception) as e: mop.match(im) - self.assertEqual( - str(e.exception), "Image must be binary, meaning it must use mode L" - ) - with self.assertRaises(Exception) as e: + assert str(e.value) == "Image must be binary, meaning it must use mode L" + with pytest.raises(Exception) as e: mop.get_on_pixels(im) - self.assertEqual( - str(e.exception), "Image must be binary, meaning it must use mode L" - ) + assert str(e.value) == "Image must be binary, meaning it must use mode L" def test_add_patterns(self): # Arrange lb = ImageMorph.LutBuilder(op_name="corner") - self.assertEqual(lb.patterns, ["1:(... ... ...)->0", "4:(00. 01. ...)->1"]) + assert lb.patterns == ["1:(... ... ...)->0", "4:(00. 01. ...)->1"] new_patterns = ["M:(00. 01. ...)->1", "N:(00. 01. ...)->1"] # Act lb.add_patterns(new_patterns) # Assert - self.assertEqual( - lb.patterns, - [ - "1:(... ... ...)->0", - "4:(00. 01. ...)->1", - "M:(00. 01. ...)->1", - "N:(00. 01. ...)->1", - ], - ) + assert lb.patterns == [ + "1:(... ... ...)->0", + "4:(00. 01. ...)->1", + "M:(00. 01. ...)->1", + "N:(00. 01. ...)->1", + ] def test_unknown_pattern(self): - self.assertRaises(Exception, ImageMorph.LutBuilder, op_name="unknown") + with pytest.raises(Exception): + ImageMorph.LutBuilder(op_name="unknown") def test_pattern_syntax_error(self): # Arrange @@ -269,11 +262,9 @@ class MorphTests(PillowTestCase): lb.add_patterns(new_patterns) # Act / Assert - with self.assertRaises(Exception) as e: + with pytest.raises(Exception) as e: lb.build_lut() - self.assertEqual( - str(e.exception), 'Syntax error in pattern "a pattern with a syntax error"' - ) + assert str(e.value) == 'Syntax error in pattern "a pattern with a syntax error"' def test_load_invalid_mrl(self): # Arrange @@ -281,9 +272,9 @@ class MorphTests(PillowTestCase): mop = ImageMorph.MorphOp() # Act / Assert - with self.assertRaises(Exception) as e: + with pytest.raises(Exception) as e: mop.load_lut(invalid_mrl) - self.assertEqual(str(e.exception), "Wrong size operator file!") + assert str(e.value) == "Wrong size operator file!" def test_roundtrip_mrl(self): # Arrange @@ -296,7 +287,7 @@ class MorphTests(PillowTestCase): mop.load_lut(tempfile) # Act / Assert - self.assertEqual(mop.lut, initial_lut) + assert mop.lut == initial_lut def test_set_lut(self): # Arrange @@ -308,20 +299,20 @@ class MorphTests(PillowTestCase): mop.set_lut(lut) # Assert - self.assertEqual(mop.lut, lut) + assert mop.lut == lut def test_wrong_mode(self): lut = ImageMorph.LutBuilder(op_name="corner").build_lut() imrgb = Image.new("RGB", (10, 10)) iml = Image.new("L", (10, 10)) - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError): _imagingmorph.apply(bytes(lut), imrgb.im.id, iml.im.id) - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError): _imagingmorph.apply(bytes(lut), iml.im.id, imrgb.im.id) - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError): _imagingmorph.match(bytes(lut), imrgb.im.id) # Should not raise diff --git a/Tests/test_imageops_usm.py b/Tests/test_imageops_usm.py index 71e858681..8bd01d588 100644 --- a/Tests/test_imageops_usm.py +++ b/Tests/test_imageops_usm.py @@ -1,3 +1,4 @@ +import pytest from PIL import Image, ImageFilter from .helper import PillowTestCase @@ -15,44 +16,52 @@ class TestImageOpsUsm(PillowTestCase): test_filter = ImageFilter.GaussianBlur(2.0) i = self.im.filter(test_filter) - self.assertEqual(i.mode, "RGB") - self.assertEqual(i.size, (128, 128)) + assert i.mode == "RGB" + assert i.size == (128, 128) test_filter = ImageFilter.UnsharpMask(2.0, 125, 8) i = self.im.filter(test_filter) - self.assertEqual(i.mode, "RGB") - self.assertEqual(i.size, (128, 128)) + assert i.mode == "RGB" + assert i.size == (128, 128) def test_usm_formats(self): usm = ImageFilter.UnsharpMask - self.assertRaises(ValueError, self.im.convert("1").filter, usm) + with pytest.raises(ValueError): + self.im.convert("1").filter(usm) self.im.convert("L").filter(usm) - self.assertRaises(ValueError, self.im.convert("I").filter, usm) - self.assertRaises(ValueError, self.im.convert("F").filter, usm) + with pytest.raises(ValueError): + self.im.convert("I").filter(usm) + with pytest.raises(ValueError): + self.im.convert("F").filter(usm) self.im.convert("RGB").filter(usm) self.im.convert("RGBA").filter(usm) self.im.convert("CMYK").filter(usm) - self.assertRaises(ValueError, self.im.convert("YCbCr").filter, usm) + with pytest.raises(ValueError): + self.im.convert("YCbCr").filter(usm) def test_blur_formats(self): blur = ImageFilter.GaussianBlur - self.assertRaises(ValueError, self.im.convert("1").filter, blur) + with pytest.raises(ValueError): + self.im.convert("1").filter(blur) blur(self.im.convert("L")) - self.assertRaises(ValueError, self.im.convert("I").filter, blur) - self.assertRaises(ValueError, self.im.convert("F").filter, blur) + with pytest.raises(ValueError): + self.im.convert("I").filter(blur) + with pytest.raises(ValueError): + self.im.convert("F").filter(blur) self.im.convert("RGB").filter(blur) self.im.convert("RGBA").filter(blur) self.im.convert("CMYK").filter(blur) - self.assertRaises(ValueError, self.im.convert("YCbCr").filter, blur) + with pytest.raises(ValueError): + self.im.convert("YCbCr").filter(blur) def test_usm_accuracy(self): src = self.snakes.convert("RGB") i = src.filter(ImageFilter.UnsharpMask(5, 1024, 0)) # Image should not be changed because it have only 0 and 255 levels. - self.assertEqual(i.tobytes(), src.tobytes()) + assert i.tobytes() == src.tobytes() def test_blur_accuracy(self): @@ -73,17 +82,17 @@ class TestImageOpsUsm(PillowTestCase): (4, 3, 2), (4, 2, 2), ]: - self.assertGreaterEqual(i.im.getpixel((x, y))[c], 250) + assert i.im.getpixel((x, y))[c] >= 250 # Fuzzy match. def gp(x, y): return i.im.getpixel((x, y)) - self.assertTrue(236 <= gp(7, 4)[0] <= 239) - self.assertTrue(236 <= gp(7, 5)[2] <= 239) - self.assertTrue(236 <= gp(7, 6)[2] <= 239) - self.assertTrue(236 <= gp(7, 7)[1] <= 239) - self.assertTrue(236 <= gp(8, 4)[0] <= 239) - self.assertTrue(236 <= gp(8, 5)[2] <= 239) - self.assertTrue(236 <= gp(8, 6)[2] <= 239) - self.assertTrue(236 <= gp(8, 7)[1] <= 239) + assert 236 <= gp(7, 4)[0] <= 239 + assert 236 <= gp(7, 5)[2] <= 239 + assert 236 <= gp(7, 6)[2] <= 239 + assert 236 <= gp(7, 7)[1] <= 239 + assert 236 <= gp(8, 4)[0] <= 239 + assert 236 <= gp(8, 5)[2] <= 239 + assert 236 <= gp(8, 6)[2] <= 239 + assert 236 <= gp(8, 7)[1] <= 239 diff --git a/Tests/test_imagepalette.py b/Tests/test_imagepalette.py index 03a4fd3a0..f606dead0 100644 --- a/Tests/test_imagepalette.py +++ b/Tests/test_imagepalette.py @@ -1,3 +1,4 @@ +import pytest from PIL import Image, ImagePalette from .helper import PillowTestCase, assert_image_equal @@ -7,9 +8,8 @@ class TestImagePalette(PillowTestCase): def test_sanity(self): ImagePalette.ImagePalette("RGB", list(range(256)) * 3) - self.assertRaises( - ValueError, ImagePalette.ImagePalette, "RGB", list(range(256)) * 2 - ) + with pytest.raises(ValueError): + ImagePalette.ImagePalette("RGB", list(range(256)) * 2) def test_getcolor(self): @@ -19,11 +19,13 @@ class TestImagePalette(PillowTestCase): for i in range(256): test_map[palette.getcolor((i, i, i))] = i - self.assertEqual(len(test_map), 256) - self.assertRaises(ValueError, palette.getcolor, (1, 2, 3)) + assert len(test_map) == 256 + with pytest.raises(ValueError): + palette.getcolor((1, 2, 3)) # Test unknown color specifier - self.assertRaises(ValueError, palette.getcolor, "unknown") + with pytest.raises(ValueError): + palette.getcolor("unknown") def test_file(self): @@ -36,12 +38,12 @@ class TestImagePalette(PillowTestCase): p = ImagePalette.load(f) # load returns raw palette information - self.assertEqual(len(p[0]), 768) - self.assertEqual(p[1], "RGB") + assert len(p[0]) == 768 + assert p[1] == "RGB" p = ImagePalette.raw(p[1], p[0]) - self.assertIsInstance(p, ImagePalette.ImagePalette) - self.assertEqual(p.palette, palette.tobytes()) + assert isinstance(p, ImagePalette.ImagePalette) + assert p.palette == palette.tobytes() def test_make_linear_lut(self): # Arrange @@ -52,11 +54,11 @@ class TestImagePalette(PillowTestCase): lut = ImagePalette.make_linear_lut(black, white) # Assert - self.assertIsInstance(lut, list) - self.assertEqual(len(lut), 256) + assert isinstance(lut, list) + assert len(lut) == 256 # Check values for i in range(0, len(lut)): - self.assertEqual(lut[i], i) + assert lut[i] == i def test_make_linear_lut_not_yet_implemented(self): # Update after FIXME @@ -65,9 +67,8 @@ class TestImagePalette(PillowTestCase): white = 255 # Act - self.assertRaises( - NotImplementedError, ImagePalette.make_linear_lut, black, white - ) + with pytest.raises(NotImplementedError): + ImagePalette.make_linear_lut(black, white) def test_make_gamma_lut(self): # Arrange @@ -77,24 +78,27 @@ class TestImagePalette(PillowTestCase): lut = ImagePalette.make_gamma_lut(exp) # Assert - self.assertIsInstance(lut, list) - self.assertEqual(len(lut), 256) + assert isinstance(lut, list) + assert len(lut) == 256 # Check a few values - self.assertEqual(lut[0], 0) - self.assertEqual(lut[63], 0) - self.assertEqual(lut[127], 8) - self.assertEqual(lut[191], 60) - self.assertEqual(lut[255], 255) + assert lut[0] == 0 + assert lut[63] == 0 + assert lut[127] == 8 + assert lut[191] == 60 + assert lut[255] == 255 def test_rawmode_valueerrors(self): # Arrange palette = ImagePalette.raw("RGB", list(range(256)) * 3) # Act / Assert - self.assertRaises(ValueError, palette.tobytes) - self.assertRaises(ValueError, palette.getcolor, (1, 2, 3)) + with pytest.raises(ValueError): + palette.tobytes() + with pytest.raises(ValueError): + palette.getcolor((1, 2, 3)) f = self.tempfile("temp.lut") - self.assertRaises(ValueError, palette.save, f) + with pytest.raises(ValueError): + palette.save(f) def test_getdata(self): # Arrange @@ -105,7 +109,7 @@ class TestImagePalette(PillowTestCase): mode, data_out = palette.getdata() # Assert - self.assertEqual(mode, "RGB;L") + assert mode == "RGB;L" def test_rawmode_getdata(self): # Arrange @@ -116,8 +120,8 @@ class TestImagePalette(PillowTestCase): rawmode, data_out = palette.getdata() # Assert - self.assertEqual(rawmode, "RGB") - self.assertEqual(data_in, data_out) + assert rawmode == "RGB" + assert data_in == data_out def test_2bit_palette(self): # issue #2258, 2 bit palettes are corrupted. @@ -132,4 +136,5 @@ class TestImagePalette(PillowTestCase): assert_image_equal(img, reloaded) def test_invalid_palette(self): - self.assertRaises(IOError, ImagePalette.load, "Tests/images/hopper.jpg") + with pytest.raises(IOError): + ImagePalette.load("Tests/images/hopper.jpg") diff --git a/Tests/test_imagepath.py b/Tests/test_imagepath.py index 35c78cd3b..62683658d 100644 --- a/Tests/test_imagepath.py +++ b/Tests/test_imagepath.py @@ -1,6 +1,7 @@ import array import struct +import pytest from PIL import Image, ImagePath from .helper import PillowTestCase @@ -12,62 +13,62 @@ class TestImagePath(PillowTestCase): p = ImagePath.Path(list(range(10))) # sequence interface - self.assertEqual(len(p), 5) - self.assertEqual(p[0], (0.0, 1.0)) - self.assertEqual(p[-1], (8.0, 9.0)) - self.assertEqual(list(p[:1]), [(0.0, 1.0)]) - with self.assertRaises(TypeError) as cm: + assert len(p) == 5 + assert p[0] == (0.0, 1.0) + assert p[-1] == (8.0, 9.0) + assert list(p[:1]) == [(0.0, 1.0)] + with pytest.raises(TypeError) as cm: p["foo"] - self.assertEqual(str(cm.exception), "Path indices must be integers, not str") - self.assertEqual( - list(p), [(0.0, 1.0), (2.0, 3.0), (4.0, 5.0), (6.0, 7.0), (8.0, 9.0)] - ) + assert str(cm.value) == "Path indices must be integers, not str" + assert list(p) == [(0.0, 1.0), (2.0, 3.0), (4.0, 5.0), (6.0, 7.0), (8.0, 9.0)] # method sanity check - self.assertEqual( - p.tolist(), [(0.0, 1.0), (2.0, 3.0), (4.0, 5.0), (6.0, 7.0), (8.0, 9.0)] - ) - self.assertEqual( - p.tolist(1), [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0] - ) + assert p.tolist() == [ + (0.0, 1.0), + (2.0, 3.0), + (4.0, 5.0), + (6.0, 7.0), + (8.0, 9.0), + ] + assert p.tolist(1) == [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0] - self.assertEqual(p.getbbox(), (0.0, 1.0, 8.0, 9.0)) + assert p.getbbox() == (0.0, 1.0, 8.0, 9.0) - self.assertEqual(p.compact(5), 2) - self.assertEqual(list(p), [(0.0, 1.0), (4.0, 5.0), (8.0, 9.0)]) + assert p.compact(5) == 2 + assert list(p) == [(0.0, 1.0), (4.0, 5.0), (8.0, 9.0)] p.transform((1, 0, 1, 0, 1, 1)) - self.assertEqual(list(p), [(1.0, 2.0), (5.0, 6.0), (9.0, 10.0)]) + assert list(p) == [(1.0, 2.0), (5.0, 6.0), (9.0, 10.0)] # alternative constructors p = ImagePath.Path([0, 1]) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] p = ImagePath.Path([0.0, 1.0]) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] p = ImagePath.Path([0, 1]) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] p = ImagePath.Path([(0, 1)]) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] p = ImagePath.Path(p) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] p = ImagePath.Path(p.tolist(0)) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] p = ImagePath.Path(p.tolist(1)) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] p = ImagePath.Path(array.array("f", [0, 1])) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] arr = array.array("f", [0, 1]) if hasattr(arr, "tobytes"): p = ImagePath.Path(arr.tobytes()) else: p = ImagePath.Path(arr.tostring()) - self.assertEqual(list(p), [(0.0, 1.0)]) + assert list(p) == [(0.0, 1.0)] def test_overflow_segfault(self): # Some Pythons fail getting the argument as an integer, and it falls # through to the sequence. Seeing this on 32-bit Windows. - with self.assertRaises((TypeError, MemoryError)): + with pytest.raises((TypeError, MemoryError)): # post patch, this fails with a memory error x = evil() diff --git a/Tests/test_imageqt.py b/Tests/test_imageqt.py index f69a21d2a..ef777374f 100644 --- a/Tests/test_imageqt.py +++ b/Tests/test_imageqt.py @@ -52,14 +52,14 @@ class TestImageQt(PillowQtTestCase, PillowTestCase): elif ImageQt.qt_version == "side2": from PySide2.QtGui import qRgb - self.assertEqual(qRgb(0, 0, 0), qRgba(0, 0, 0, 255)) + assert qRgb(0, 0, 0) == qRgba(0, 0, 0, 255) def checkrgb(r, g, b): val = ImageQt.rgb(r, g, b) val = val % 2 ** 24 # drop the alpha - self.assertEqual(val >> 16, r) - self.assertEqual(((val >> 8) % 2 ** 8), g) - self.assertEqual(val % 2 ** 8, b) + assert val >> 16 == r + assert ((val >> 8) % 2 ** 8) == g + assert val % 2 ** 8 == b checkrgb(0, 0, 0) checkrgb(255, 0, 0) diff --git a/Tests/test_imagesequence.py b/Tests/test_imagesequence.py index e0c3f8dec..4af196ce9 100644 --- a/Tests/test_imagesequence.py +++ b/Tests/test_imagesequence.py @@ -1,3 +1,4 @@ +import pytest from PIL import Image, ImageSequence, TiffImagePlugin from .helper import PillowTestCase, assert_image_equal, hopper, skip_unless_feature @@ -16,32 +17,35 @@ class TestImageSequence(PillowTestCase): index = 0 for frame in seq: assert_image_equal(im, frame) - self.assertEqual(im.tell(), index) + assert im.tell() == index index += 1 - self.assertEqual(index, 1) + assert index == 1 - self.assertRaises(AttributeError, ImageSequence.Iterator, 0) + with pytest.raises(AttributeError): + ImageSequence.Iterator(0) def test_iterator(self): with Image.open("Tests/images/multipage.tiff") as im: i = ImageSequence.Iterator(im) for index in range(0, im.n_frames): - self.assertEqual(i[index], next(i)) - self.assertRaises(IndexError, lambda: i[index + 1]) - self.assertRaises(StopIteration, next, i) + assert i[index] == next(i) + with pytest.raises(IndexError): + i[index + 1] + with pytest.raises(StopIteration): + next(i) def test_iterator_min_frame(self): with Image.open("Tests/images/hopper.psd") as im: i = ImageSequence.Iterator(im) for index in range(1, im.n_frames): - self.assertEqual(i[index], next(i)) + assert i[index] == next(i) def _test_multipage_tiff(self): with Image.open("Tests/images/multipage.tiff") as im: for index, frame in enumerate(ImageSequence.Iterator(im)): frame.load() - self.assertEqual(index, im.tell()) + assert index == im.tell() frame.convert("RGB") def test_tiff(self): @@ -69,23 +73,23 @@ class TestImageSequence(PillowTestCase): color1 = im.getpalette()[0:3] im.seek(0) color2 = im.getpalette()[0:3] - self.assertEqual(color1, color2) + assert color1 == color2 def test_all_frames(self): # Test a single image with Image.open("Tests/images/iss634.gif") as im: ims = ImageSequence.all_frames(im) - self.assertEqual(len(ims), 42) + assert len(ims) == 42 for i, im_frame in enumerate(ims): - self.assertFalse(im_frame is im) + assert im_frame is not im im.seek(i) assert_image_equal(im, im_frame) # Test a series of images ims = ImageSequence.all_frames([im, hopper(), im]) - self.assertEqual(len(ims), 85) + assert len(ims) == 85 # Test an operation ims = ImageSequence.all_frames(im, lambda im_frame: im_frame.rotate(90)) diff --git a/Tests/test_imagewin.py b/Tests/test_imagewin.py index 1cd8c674e..d6e63d44f 100644 --- a/Tests/test_imagewin.py +++ b/Tests/test_imagewin.py @@ -18,7 +18,7 @@ class TestImageWin(PillowTestCase): dc2 = int(hdc) # Assert - self.assertEqual(dc2, 50) + assert dc2 == 50 def test_hwnd(self): # Arrange @@ -29,7 +29,7 @@ class TestImageWin(PillowTestCase): wnd2 = int(hwnd) # Assert - self.assertEqual(wnd2, 50) + assert wnd2 == 50 @unittest.skipUnless(is_win32(), "Windows only") @@ -42,7 +42,7 @@ class TestImageWinDib(PillowTestCase): dib = ImageWin.Dib(im) # Assert - self.assertEqual(dib.size, im.size) + assert dib.size == im.size def test_dib_mode_string(self): # Arrange @@ -53,7 +53,7 @@ class TestImageWinDib(PillowTestCase): dib = ImageWin.Dib(mode, size) # Assert - self.assertEqual(dib.size, (128, 128)) + assert dib.size == (128, 128) def test_dib_paste(self): # Arrange @@ -67,7 +67,7 @@ class TestImageWinDib(PillowTestCase): dib.paste(im) # Assert - self.assertEqual(dib.size, (128, 128)) + assert dib.size == (128, 128) def test_dib_paste_bbox(self): # Arrange @@ -82,7 +82,7 @@ class TestImageWinDib(PillowTestCase): dib.paste(im, bbox) # Assert - self.assertEqual(dib.size, (128, 128)) + assert dib.size == (128, 128) def test_dib_frombytes_tobytes_roundtrip(self): # Arrange @@ -95,7 +95,7 @@ class TestImageWinDib(PillowTestCase): dib2 = ImageWin.Dib(mode, size) # Confirm they're different - self.assertNotEqual(dib1.tobytes(), dib2.tobytes()) + assert dib1.tobytes() != dib2.tobytes() # Act # Make one the same as the using tobytes()/frombytes() @@ -104,4 +104,4 @@ class TestImageWinDib(PillowTestCase): # Assert # Confirm they're the same - self.assertEqual(dib1.tobytes(), dib2.tobytes()) + assert dib1.tobytes() == dib2.tobytes() diff --git a/Tests/test_lib_pack.py b/Tests/test_lib_pack.py index f9e6e7c4c..d75176601 100644 --- a/Tests/test_lib_pack.py +++ b/Tests/test_lib_pack.py @@ -1,5 +1,6 @@ import sys +import pytest from PIL import Image from .helper import PillowTestCase @@ -20,7 +21,7 @@ class TestLibPack(PillowTestCase): data_len = data * len(pixels) data = bytes(range(1, data_len + 1)) - self.assertEqual(data, im.tobytes("raw", rawmode)) + assert data == im.tobytes("raw", rawmode) def test_1(self): self.assert_pack("1", "1", b"\x01", 0, 0, 0, 0, 0, 0, 0, X) @@ -234,7 +235,7 @@ class TestLibUnpack(PillowTestCase): im = Image.frombytes(mode, (len(pixels), 1), data, "raw", rawmode, 0, 1) for x, pixel in enumerate(pixels): - self.assertEqual(pixel, im.getpixel((x, 0))) + assert pixel == im.getpixel((x, 0)) def test_1(self): self.assert_unpack("1", "1", b"\x01", 0, 0, 0, 0, 0, 0, 0, X) @@ -719,6 +720,9 @@ class TestLibUnpack(PillowTestCase): self.assert_unpack("CMYK", "CMYK;16N", 8, (1, 3, 5, 7), (9, 11, 13, 15)) def test_value_error(self): - self.assertRaises(ValueError, self.assert_unpack, "L", "L", 0, 0) - self.assertRaises(ValueError, self.assert_unpack, "RGB", "RGB", 2, 0) - self.assertRaises(ValueError, self.assert_unpack, "CMYK", "CMYK", 2, 0) + with pytest.raises(ValueError): + self.assert_unpack("L", "L", 0, 0) + with pytest.raises(ValueError): + self.assert_unpack("RGB", "RGB", 2, 0) + with pytest.raises(ValueError): + self.assert_unpack("CMYK", "CMYK", 2, 0) diff --git a/Tests/test_mode_i16.py b/Tests/test_mode_i16.py index fcd45b3c1..c0ffb3e09 100644 --- a/Tests/test_mode_i16.py +++ b/Tests/test_mode_i16.py @@ -9,7 +9,7 @@ class TestModeI16(PillowTestCase): def verify(self, im1): im2 = self.original.copy() - self.assertEqual(im1.size, im2.size) + assert im1.size == im2.size pix1 = im1.load() pix2 = im2.load() for y in range(im1.size[1]): @@ -17,14 +17,8 @@ class TestModeI16(PillowTestCase): xy = x, y p1 = pix1[xy] p2 = pix2[xy] - self.assertEqual( - p1, - p2, - ( - "got {!r} from mode {} at {}, expected {!r}".format( - p1, im1.mode, xy, p2 - ) - ), + assert p1 == p2, "got {!r} from mode {} at {}, expected {!r}".format( + p1, im1.mode, xy, p2 ) def test_basic(self): @@ -63,10 +57,10 @@ class TestModeI16(PillowTestCase): self.verify(imOut) imIn = Image.new(mode, (1, 1), 1) - self.assertEqual(imIn.getpixel((0, 0)), 1) + assert imIn.getpixel((0, 0)) == 1 imIn.putpixel((0, 0), 2) - self.assertEqual(imIn.getpixel((0, 0)), 2) + assert imIn.getpixel((0, 0)) == 2 if mode == "L": maximum = 255 @@ -74,10 +68,10 @@ class TestModeI16(PillowTestCase): maximum = 32767 imIn = Image.new(mode, (1, 1), 256) - self.assertEqual(imIn.getpixel((0, 0)), min(256, maximum)) + assert imIn.getpixel((0, 0)) == min(256, maximum) imIn.putpixel((0, 0), 512) - self.assertEqual(imIn.getpixel((0, 0)), min(512, maximum)) + assert imIn.getpixel((0, 0)) == min(512, maximum) basic("L") @@ -93,10 +87,10 @@ class TestModeI16(PillowTestCase): order = 1 if Image._ENDIAN == "<" else -1 - self.assertEqual(tobytes("L"), b"\x01") - self.assertEqual(tobytes("I;16"), b"\x01\x00") - self.assertEqual(tobytes("I;16B"), b"\x00\x01") - self.assertEqual(tobytes("I"), b"\x01\x00\x00\x00"[::order]) + assert tobytes("L") == b"\x01" + assert tobytes("I;16") == b"\x01\x00" + assert tobytes("I;16B") == b"\x00\x01" + assert tobytes("I") == b"\x01\x00\x00\x00"[::order] def test_convert(self): diff --git a/Tests/test_pickle.py b/Tests/test_pickle.py index 678934dc2..b95544d0f 100644 --- a/Tests/test_pickle.py +++ b/Tests/test_pickle.py @@ -20,7 +20,7 @@ class TestPickle(PillowTestCase): loaded_im = pickle.load(f) # Assert - self.assertEqual(im, loaded_im) + assert im == loaded_im def helper_pickle_string( self, pickle, protocol=0, test_file="Tests/images/hopper.jpg", mode=None @@ -34,7 +34,7 @@ class TestPickle(PillowTestCase): loaded_im = pickle.loads(dumped_string) # Assert - self.assertEqual(im, loaded_im) + assert im == loaded_im def test_pickle_image(self): # Act / Assert @@ -86,4 +86,4 @@ class TestPickle(PillowTestCase): loaded_im = pickle.load(f) im.mode = "PA" - self.assertEqual(im, loaded_im) + assert im == loaded_im diff --git a/Tests/test_qt_image_toqimage.py b/Tests/test_qt_image_toqimage.py index 3733789f1..8283753b9 100644 --- a/Tests/test_qt_image_toqimage.py +++ b/Tests/test_qt_image_toqimage.py @@ -20,8 +20,8 @@ class TestToQImage(PillowQtTestCase, PillowTestCase): src = hopper(mode) data = ImageQt.toqimage(src) - self.assertIsInstance(data, QImage) - self.assertFalse(data.isNull()) + assert isinstance(data, QImage) + assert not data.isNull() # reload directly from the qimage rt = ImageQt.fromqimage(data) diff --git a/Tests/test_qt_image_toqpixmap.py b/Tests/test_qt_image_toqpixmap.py index 2c07f1bf5..70b0d6839 100644 --- a/Tests/test_qt_image_toqpixmap.py +++ b/Tests/test_qt_image_toqpixmap.py @@ -12,8 +12,8 @@ class TestToQPixmap(PillowQPixmapTestCase, PillowTestCase): for mode in ("1", "RGB", "RGBA", "L", "P"): data = ImageQt.toqpixmap(hopper(mode)) - self.assertIsInstance(data, QPixmap) - self.assertFalse(data.isNull()) + assert isinstance(data, QPixmap) + assert not data.isNull() # Test saving the file tempfile = self.tempfile("temp_{}.png".format(mode)) diff --git a/Tests/test_tiff_ifdrational.py b/Tests/test_tiff_ifdrational.py index e570ecb99..a044d04b3 100644 --- a/Tests/test_tiff_ifdrational.py +++ b/Tests/test_tiff_ifdrational.py @@ -11,8 +11,8 @@ class Test_IFDRational(PillowTestCase): t = IFDRational(num, denom) - self.assertEqual(target, t) - self.assertEqual(t, target) + assert target == t + assert t == target def test_sanity(self): @@ -33,13 +33,13 @@ class Test_IFDRational(PillowTestCase): xres = IFDRational(72) yres = IFDRational(72) - self.assertIsNotNone(xres._val) - self.assertIsNotNone(xres.numerator) - self.assertIsNotNone(xres.denominator) - self.assertIsNotNone(yres._val) + assert xres._val is not None + assert xres.numerator is not None + assert xres.denominator is not None + assert yres._val is not None - self.assertTrue(xres and 1) - self.assertTrue(xres and yres) + assert xres and 1 + assert xres and yres def test_ifd_rational_save(self): methods = (True, False) @@ -55,6 +55,4 @@ class Test_IFDRational(PillowTestCase): im.save(out, dpi=(res, res), compression="raw") with Image.open(out) as reloaded: - self.assertEqual( - float(IFDRational(301, 1)), float(reloaded.tag_v2[282]) - ) + assert float(IFDRational(301, 1)) == float(reloaded.tag_v2[282])