Converted most assert statements to pytest

This commit is contained in:
Andrew Murray 2020-02-23 00:06:21 +11:00
parent 20d6b6271c
commit 8482919a37
53 changed files with 1716 additions and 1669 deletions

View File

@ -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()

View File

@ -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__":

View File

@ -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

View File

@ -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), "<Color3DLUT from list size=2x2x2 channels=3>")
assert repr(lut) == "<Color3DLUT from list size=2x2x2 channels=3>"
lut = ImageFilter.Color3DLUT(
(3, 4, 5),
@ -395,8 +396,9 @@ class TestColorLut3DFilter(PillowTestCase):
target_mode="YCbCr",
_copy_table=False,
)
self.assertEqual(
repr(lut), "<Color3DLUT from array size=3x4x5 channels=4 target_mode=YCbCr>"
assert (
repr(lut)
== "<Color3DLUT from array size=3x4x5 channels=4 target_mode=YCbCr>"
)
@ -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

View File

@ -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(

View File

@ -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"

View File

@ -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)

View File

@ -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)

View File

@ -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)

View File

@ -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],
{
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)

View File

@ -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)

View File

@ -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:
assert c_float(val).value == c_float(value).value, (
"%s didn't roundtrip" % tag
)
else:
self.assertEqual(
c_float(val).value,
c_float(value).value,
msg="%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,
[
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

View File

@ -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)

View File

@ -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)

View File

@ -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)

View File

@ -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))

View File

@ -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

View File

@ -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:

View File

@ -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"

View File

@ -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")

View File

@ -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):

View File

@ -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)

View File

@ -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()

View File

@ -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,18 +75,13 @@ 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(
{
assert {
"YResolution": IFDRational(4294967295, 113653537),
"PlanarConfiguration": 1,
"BitsPerSample": (1,),
@ -103,12 +98,9 @@ class TestFileTiffMetadata(PillowTestCase):
"StripByteCounts": (1968,),
"SamplesPerPixel": 1,
"StripOffsets": (8,),
},
img.tag_v2.named(),
)
} == img.tag_v2.named()
self.assertEqual(
{
assert {
"YResolution": ((4294967295, 113653537),),
"PlanarConfiguration": (1,),
"BitsPerSample": (1,),
@ -125,9 +117,7 @@ class TestFileTiffMetadata(PillowTestCase):
"StripByteCounts": (1968,),
"SamplesPerPixel": (1,),
"StripOffsets": (8,),
},
img.tag.named(),
)
} == 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()

View File

@ -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

View File

@ -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)

View File

@ -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()

View File

@ -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], "<PIL.Image.Image image mode=L size=100x100 at")
self.assertEqual(im.mode, "L")
self.assertEqual(im.size, (100, 100))
assert repr(im)[:45] == "<PIL.Image.Image image mode=L size=100x100 at"
assert im.mode == "L"
assert im.size == (100, 100)
im = Image.new("RGB", (100, 100))
self.assertEqual(repr(im)[:45], "<PIL.Image.Image image mode=RGB size=100x100 ")
self.assertEqual(im.mode, "RGB")
self.assertEqual(im.size, (100, 100))
assert repr(im)[:45] == "<PIL.Image.Image image mode=RGB size=100x100 "
assert im.mode == "RGB"
assert im.size == (100, 100)
Image.new("L", (100, 100), None)
im2 = Image.new("L", (100, 100), 0)
im3 = Image.new("L", (100, 100), "black")
self.assertEqual(im2.getcolors(), [(10000, 0)])
self.assertEqual(im3.getcolors(), [(10000, 0)])
assert im2.getcolors() == [(10000, 0)]
assert im3.getcolors() == [(10000, 0)]
self.assertRaises(ValueError, Image.new, "X", (100, 100))
self.assertRaises(ValueError, Image.new, "", (100, 100))
# self.assertRaises(MemoryError, Image.new, "L", (1000000, 1000000))
with pytest.raises(ValueError):
Image.new("X", (100, 100))
with pytest.raises(ValueError):
Image.new("", (100, 100))
# with pytest.raises(MemoryError):
# Image.new("L", (1000000, 1000000))
def test_width_height(self):
im = Image.new("RGB", (1, 2))
self.assertEqual(im.width, 1)
self.assertEqual(im.height, 2)
assert im.width == 1
assert im.height == 2
with self.assertRaises(AttributeError):
with pytest.raises(AttributeError):
im.size = (3, 4)
def test_invalid_image(self):
import io
im = io.BytesIO(b"")
self.assertRaises(UnidentifiedImageError, Image.open, im)
with pytest.raises(UnidentifiedImageError):
Image.open(im)
def test_bad_mode(self):
self.assertRaises(ValueError, Image.open, "filename", "bad mode")
with pytest.raises(ValueError):
Image.open("filename", "bad mode")
def test_stringio(self):
self.assertRaises(ValueError, Image.open, io.StringIO())
with pytest.raises(ValueError):
Image.open(io.StringIO())
def test_pathlib(self):
from PIL.Image import Path
with Image.open(Path("Tests/images/multipage-mmap.tiff")) as im:
self.assertEqual(im.mode, "P")
self.assertEqual(im.size, (10, 10))
assert im.mode == "P"
assert im.size == (10, 10)
with Image.open(Path("Tests/images/hopper.jpg")) as im:
self.assertEqual(im.mode, "RGB")
self.assertEqual(im.size, (128, 128))
assert im.mode == "RGB"
assert im.size == (128, 128)
temp_file = self.tempfile("temp.jpg")
if os.path.exists(temp_file):
@ -145,17 +151,18 @@ class TestImage(PillowTestCase):
def test_unknown_extension(self):
im = hopper()
temp_file = self.tempfile("temp.unknown")
self.assertRaises(ValueError, im.save, temp_file)
with pytest.raises(ValueError):
im.save(temp_file)
def test_internals(self):
im = Image.new("L", (100, 100))
im.readonly = 1
im._copy()
self.assertFalse(im.readonly)
assert not im.readonly
im.readonly = 1
im.paste(0, (0, 0, 100, 100))
self.assertFalse(im.readonly)
assert not im.readonly
@unittest.skipIf(is_win32(), "Test requires opening tempfile twice")
def test_readonly_save(self):
@ -163,7 +170,7 @@ class TestImage(PillowTestCase):
shutil.copy("Tests/images/rgb32bf-rgba.bmp", temp_file)
with Image.open(temp_file) as im:
self.assertTrue(im.readonly)
assert im.readonly
im.save(temp_file)
def test_dump(self):
@ -174,7 +181,8 @@ class TestImage(PillowTestCase):
im._dump(self.tempfile("temp_RGB.ppm"))
im = Image.new("HSV", (10, 10))
self.assertRaises(ValueError, im._dump, self.tempfile("temp_HSV.ppm"))
with pytest.raises(ValueError):
im._dump(self.tempfile("temp_HSV.ppm"))
def test_comparison_with_other_type(self):
# Arrange
@ -183,8 +191,8 @@ class TestImage(PillowTestCase):
# Act/Assert
# Shouldn't cause AttributeError (#774)
self.assertFalse(item is None)
self.assertFalse(item == num)
assert item is not None
assert item != num
def test_expand_x(self):
# Arrange
@ -196,8 +204,8 @@ class TestImage(PillowTestCase):
im = im._expand(xmargin)
# Assert
self.assertEqual(im.size[0], orig_size[0] + 2 * xmargin)
self.assertEqual(im.size[1], orig_size[1] + 2 * xmargin)
assert im.size[0] == orig_size[0] + 2 * xmargin
assert im.size[1] == orig_size[1] + 2 * xmargin
def test_expand_xy(self):
# Arrange
@ -210,21 +218,25 @@ class TestImage(PillowTestCase):
im = im._expand(xmargin, ymargin)
# Assert
self.assertEqual(im.size[0], orig_size[0] + 2 * xmargin)
self.assertEqual(im.size[1], orig_size[1] + 2 * ymargin)
assert im.size[0] == orig_size[0] + 2 * xmargin
assert im.size[1] == orig_size[1] + 2 * ymargin
def test_getbands(self):
# Assert
self.assertEqual(hopper("RGB").getbands(), ("R", "G", "B"))
self.assertEqual(hopper("YCbCr").getbands(), ("Y", "Cb", "Cr"))
assert hopper("RGB").getbands() == ("R", "G", "B")
assert hopper("YCbCr").getbands() == ("Y", "Cb", "Cr")
def test_getchannel_wrong_params(self):
im = hopper()
self.assertRaises(ValueError, im.getchannel, -1)
self.assertRaises(ValueError, im.getchannel, 3)
self.assertRaises(ValueError, im.getchannel, "Z")
self.assertRaises(ValueError, im.getchannel, "1")
with pytest.raises(ValueError):
im.getchannel(-1)
with pytest.raises(ValueError):
im.getchannel(3)
with pytest.raises(ValueError):
im.getchannel("Z")
with pytest.raises(ValueError):
im.getchannel("1")
def test_getchannel(self):
im = hopper("YCbCr")
@ -245,7 +257,7 @@ class TestImage(PillowTestCase):
bbox = im.getbbox()
# Assert
self.assertEqual(bbox, (0, 0, 128, 128))
assert bbox == (0, 0, 128, 128)
def test_ne(self):
# Arrange
@ -253,7 +265,7 @@ class TestImage(PillowTestCase):
im2 = Image.new("RGB", (25, 25), "white")
# Act / Assert
self.assertNotEqual(im1, im2)
assert im1 != im2
def test_alpha_composite(self):
# https://stackoverflow.com/questions/3374878
@ -284,7 +296,7 @@ class TestImage(PillowTestCase):
# Assert
img_colors = sorted(img.getcolors())
self.assertEqual(img_colors, expected_colors)
assert img_colors == expected_colors
def test_alpha_inplace(self):
src = Image.new("RGBA", (128, 128), "blue")
@ -304,31 +316,35 @@ class TestImage(PillowTestCase):
offset = src.copy()
offset.alpha_composite(over, (64, 64))
assert_image_equal(offset.crop((64, 64, 127, 127)), target.crop((0, 0, 63, 63)))
self.assertEqual(offset.size, (128, 128))
assert offset.size == (128, 128)
# offset and crop
box = src.copy()
box.alpha_composite(over, (64, 64), (0, 0, 32, 32))
assert_image_equal(box.crop((64, 64, 96, 96)), target.crop((0, 0, 32, 32)))
assert_image_equal(box.crop((96, 96, 128, 128)), src.crop((0, 0, 32, 32)))
self.assertEqual(box.size, (128, 128))
assert box.size == (128, 128)
# source point
source = src.copy()
source.alpha_composite(over, (32, 32), (32, 32, 96, 96))
assert_image_equal(source.crop((32, 32, 96, 96)), target.crop((32, 32, 96, 96)))
self.assertEqual(source.size, (128, 128))
assert source.size == (128, 128)
# errors
self.assertRaises(ValueError, source.alpha_composite, over, "invalid source")
self.assertRaises(
ValueError, source.alpha_composite, over, (0, 0), "invalid destination"
)
self.assertRaises(ValueError, source.alpha_composite, over, 0)
self.assertRaises(ValueError, source.alpha_composite, over, (0, 0), 0)
self.assertRaises(ValueError, source.alpha_composite, over, (0, -1))
self.assertRaises(ValueError, source.alpha_composite, over, (0, 0), (0, -1))
with pytest.raises(ValueError):
source.alpha_composite(over, "invalid source")
with pytest.raises(ValueError):
source.alpha_composite(over, (0, 0), "invalid destination")
with pytest.raises(ValueError):
source.alpha_composite(over, 0)
with pytest.raises(ValueError):
source.alpha_composite(over, (0, 0), 0)
with pytest.raises(ValueError):
source.alpha_composite(over, (0, -1))
with pytest.raises(ValueError):
source.alpha_composite(over, (0, 0), (0, -1))
def test_registered_extensions_uninitialized(self):
# Arrange
@ -340,11 +356,11 @@ class TestImage(PillowTestCase):
Image.registered_extensions()
# Assert
self.assertEqual(Image._initialized, 2)
assert Image._initialized == 2
# Restore the original state and assert
Image.EXTENSION = extension
self.assertTrue(Image.EXTENSION)
assert Image.EXTENSION
def test_registered_extensions(self):
# Arrange
@ -356,9 +372,9 @@ class TestImage(PillowTestCase):
extensions = Image.registered_extensions()
# Assert
self.assertTrue(extensions)
assert extensions
for ext in [".cur", ".icns", ".tif", ".tiff"]:
self.assertIn(ext, extensions)
assert ext in extensions
def test_effect_mandelbrot(self):
# Arrange
@ -370,7 +386,7 @@ class TestImage(PillowTestCase):
im = Image.effect_mandelbrot(size, extent, quality)
# Assert
self.assertEqual(im.size, (512, 512))
assert im.size == (512, 512)
with Image.open("Tests/images/effect_mandelbrot.png") as im2:
assert_image_equal(im, im2)
@ -383,7 +399,8 @@ class TestImage(PillowTestCase):
quality = 1
# Act/Assert
self.assertRaises(ValueError, Image.effect_mandelbrot, size, extent, quality)
with pytest.raises(ValueError):
Image.effect_mandelbrot(size, extent, quality)
def test_effect_noise(self):
# Arrange
@ -394,8 +411,8 @@ class TestImage(PillowTestCase):
im = Image.effect_noise(size, sigma)
# Assert
self.assertEqual(im.size, (100, 100))
self.assertEqual(im.mode, "L")
assert im.size == (100, 100)
assert im.mode == "L"
p0 = im.getpixel((0, 0))
p1 = im.getpixel((0, 1))
p2 = im.getpixel((0, 2))
@ -412,34 +429,34 @@ class TestImage(PillowTestCase):
im2 = im.effect_spread(distance)
# Assert
self.assertEqual(im.size, (128, 128))
assert im.size == (128, 128)
with Image.open("Tests/images/effect_spread.png") as im3:
assert_image_similar(im2, im3, 110)
def test_check_size(self):
# Checking that the _check_size function throws value errors
# when we want it to.
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
Image.new("RGB", 0) # not a tuple
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
Image.new("RGB", (0,)) # Tuple too short
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
Image.new("RGB", (-1, -1)) # w,h < 0
# this should pass with 0 sized images, #2259
im = Image.new("L", (0, 0))
self.assertEqual(im.size, (0, 0))
assert im.size == (0, 0)
im = Image.new("L", (0, 100))
self.assertEqual(im.size, (0, 100))
assert im.size == (0, 100)
im = Image.new("L", (100, 0))
self.assertEqual(im.size, (100, 0))
assert im.size == (100, 0)
self.assertTrue(Image.new("RGB", (1, 1)))
assert Image.new("RGB", (1, 1))
# Should pass lists too
i = Image.new("RGB", [1, 1])
self.assertIsInstance(i.size, tuple)
assert isinstance(i.size, tuple)
def test_storage_neg(self):
# Storage.c accepted negative values for xsize, ysize. Was
@ -447,7 +464,7 @@ class TestImage(PillowTestCase):
# removed Calling directly into core to test the error in
# Storage.c, rather than the size check above
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
Image.core.fill("RGB", (2, -2), (0, 0, 0))
def test_offset_not_implemented(self):
@ -455,17 +472,20 @@ class TestImage(PillowTestCase):
with hopper() as im:
# Act / Assert
self.assertRaises(NotImplementedError, im.offset, None)
with pytest.raises(NotImplementedError):
im.offset(None)
def test_fromstring(self):
self.assertRaises(NotImplementedError, Image.fromstring)
with pytest.raises(NotImplementedError):
Image.fromstring()
def test_linear_gradient_wrong_mode(self):
# Arrange
wrong_mode = "RGB"
# Act / Assert
self.assertRaises(ValueError, Image.linear_gradient, wrong_mode)
with pytest.raises(ValueError):
Image.linear_gradient(wrong_mode)
def test_linear_gradient(self):
@ -477,10 +497,10 @@ class TestImage(PillowTestCase):
im = Image.linear_gradient(mode)
# Assert
self.assertEqual(im.size, (256, 256))
self.assertEqual(im.mode, mode)
self.assertEqual(im.getpixel((0, 0)), 0)
self.assertEqual(im.getpixel((255, 255)), 255)
assert im.size == (256, 256)
assert im.mode == mode
assert im.getpixel((0, 0)) == 0
assert im.getpixel((255, 255)) == 255
with Image.open(target_file) as target:
target = target.convert(mode)
assert_image_equal(im, target)
@ -490,7 +510,8 @@ class TestImage(PillowTestCase):
wrong_mode = "RGB"
# Act / Assert
self.assertRaises(ValueError, Image.radial_gradient, wrong_mode)
with pytest.raises(ValueError):
Image.radial_gradient(wrong_mode)
def test_radial_gradient(self):
@ -502,10 +523,10 @@ class TestImage(PillowTestCase):
im = Image.radial_gradient(mode)
# Assert
self.assertEqual(im.size, (256, 256))
self.assertEqual(im.mode, mode)
self.assertEqual(im.getpixel((0, 0)), 255)
self.assertEqual(im.getpixel((128, 128)), 0)
assert im.size == (256, 256)
assert im.mode == mode
assert im.getpixel((0, 0)) == 255
assert im.getpixel((128, 128)) == 0
with Image.open(target_file) as target:
target = target.convert(mode)
assert_image_equal(im, target)
@ -524,12 +545,13 @@ class TestImage(PillowTestCase):
for ext in exts:
del Image.EXTENSION[ext]
self.assertEqual(ext_individual, ext_multiple)
assert ext_individual == ext_multiple
def test_remap_palette(self):
# Test illegal image mode
with hopper() as im:
self.assertRaises(ValueError, im.remap_palette, None)
with pytest.raises(ValueError):
im.remap_palette(None)
def test__new(self):
im = hopper("RGB")
@ -542,13 +564,13 @@ class TestImage(PillowTestCase):
def _make_new(base_image, im, palette_result=None):
new_im = base_image._new(im)
self.assertEqual(new_im.mode, im.mode)
self.assertEqual(new_im.size, im.size)
self.assertEqual(new_im.info, base_image.info)
assert new_im.mode == im.mode
assert new_im.size == im.size
assert new_im.info == base_image.info
if palette_result is not None:
self.assertEqual(new_im.palette.tobytes(), palette_result.tobytes())
assert new_im.palette.tobytes() == palette_result.tobytes()
else:
self.assertIsNone(new_im.palette)
assert new_im.palette is None
_make_new(im, im_p, im_p.palette)
_make_new(im_p, im, None)
@ -587,7 +609,7 @@ class TestImage(PillowTestCase):
with Image.open(fp) as im:
im.load()
self.assertFalse(fp.closed)
assert not fp.closed
def test_overrun(self):
for file in [
@ -603,14 +625,14 @@ class TestImage(PillowTestCase):
im.load()
self.assertFail()
except OSError as e:
self.assertEqual(str(e), "buffer overrun when reading image file")
assert str(e) == "buffer overrun when reading image file"
with Image.open("Tests/images/fli_overrun2.bin") as im:
try:
im.seek(1)
self.assertFail()
except OSError as e:
self.assertEqual(str(e), "buffer overrun when reading image file")
assert str(e) == "buffer overrun when reading image file"
class MockEncoder:
@ -627,19 +649,13 @@ class TestRegistry(PillowTestCase):
def test_encode_registry(self):
Image.register_encoder("MOCK", mock_encode)
self.assertIn("MOCK", Image.ENCODERS)
assert "MOCK" in Image.ENCODERS
enc = Image._getencoder("RGB", "MOCK", ("args",), extra=("extra",))
self.assertIsInstance(enc, MockEncoder)
self.assertEqual(enc.args, ("RGB", "args", "extra"))
assert isinstance(enc, MockEncoder)
assert enc.args == ("RGB", "args", "extra")
def test_encode_registry_fail(self):
self.assertRaises(
IOError,
Image._getencoder,
"RGB",
"DoesNotExist",
("args",),
extra=("extra",),
)
with pytest.raises(IOError):
Image._getencoder("RGB", "DoesNotExist", ("args",), extra=("extra",))

View File

@ -5,6 +5,7 @@ import sys
import unittest
from distutils import ccompiler, sysconfig
import pytest
from PIL import Image
from .helper import PillowTestCase, assert_image_equal, hopper, is_win32, on_ci
@ -55,7 +56,7 @@ class TestImagePutPixel(AccessTest):
pos = x, y
im2.putpixel(pos, im1.getpixel(pos))
self.assertFalse(im2.readonly)
assert not im2.readonly
assert_image_equal(im1, im2)
im2 = Image.new(im1.mode, im1.size, 0)
@ -74,8 +75,8 @@ class TestImagePutPixel(AccessTest):
im2 = Image.new(im1.mode, im1.size, 0)
width, height = im1.size
self.assertEqual(im1.getpixel((0, 0)), im1.getpixel((-width, -height)))
self.assertEqual(im1.getpixel((-1, -1)), im1.getpixel((width - 1, height - 1)))
assert im1.getpixel((0, 0)) == im1.getpixel((-width, -height))
assert im1.getpixel((-1, -1)) == im1.getpixel((width - 1, height - 1))
for y in range(-1, -im1.size[1] - 1, -1):
for x in range(-1, -im1.size[0] - 1, -1):
@ -92,7 +93,7 @@ class TestImagePutPixel(AccessTest):
pos = x, y
im2.putpixel(pos, im1.getpixel(pos))
self.assertFalse(im2.readonly)
assert not im2.readonly
assert_image_equal(im1, im2)
im2 = Image.new(im1.mode, im1.size, 0)
@ -123,54 +124,45 @@ class TestImageGetPixel(AccessTest):
# check putpixel
im = Image.new(mode, (1, 1), None)
im.putpixel((0, 0), c)
self.assertEqual(
im.getpixel((0, 0)),
c,
"put/getpixel roundtrip failed for mode {}, color {}".format(mode, c),
)
assert (
im.getpixel((0, 0)) == c
), "put/getpixel roundtrip failed for mode {}, color {}".format(mode, c)
# check putpixel negative index
im.putpixel((-1, -1), c)
self.assertEqual(
im.getpixel((-1, -1)),
c,
"put/getpixel roundtrip negative index failed"
" for mode %s, color %s" % (mode, c),
assert im.getpixel((-1, -1)) == c, (
"put/getpixel roundtrip negative index failed for mode %s, color %s"
% (mode, c)
)
# Check 0
im = Image.new(mode, (0, 0), None)
with self.assertRaises(IndexError):
with pytest.raises(IndexError):
im.putpixel((0, 0), c)
with self.assertRaises(IndexError):
with pytest.raises(IndexError):
im.getpixel((0, 0))
# Check 0 negative index
with self.assertRaises(IndexError):
with pytest.raises(IndexError):
im.putpixel((-1, -1), c)
with self.assertRaises(IndexError):
with pytest.raises(IndexError):
im.getpixel((-1, -1))
# check initial color
im = Image.new(mode, (1, 1), c)
self.assertEqual(
im.getpixel((0, 0)),
c,
"initial color failed for mode {}, color {} ".format(mode, c),
)
assert (
im.getpixel((0, 0)) == c
), "initial color failed for mode {}, color {} ".format(mode, c)
# check initial color negative index
self.assertEqual(
im.getpixel((-1, -1)),
c,
"initial color failed with negative index"
"for mode %s, color %s " % (mode, c),
)
assert (
im.getpixel((-1, -1)) == c
), "initial color failed with negative index for mode %s, color %s " % (mode, c)
# Check 0
im = Image.new(mode, (0, 0), c)
with self.assertRaises(IndexError):
with pytest.raises(IndexError):
im.getpixel((0, 0))
# Check 0 negative index
with self.assertRaises(IndexError):
with pytest.raises(IndexError):
im.getpixel((-1, -1))
def test_basic(self):
@ -205,7 +197,7 @@ class TestImageGetPixel(AccessTest):
for color in [(255, 0, 0), (255, 0, 0, 255)]:
im = Image.new("P", (1, 1), 0)
im.putpixel((0, 0), color)
self.assertEqual(im.convert("RGB").getpixel((0, 0)), (255, 0, 0))
assert im.convert("RGB").getpixel((0, 0)) == (255, 0, 0)
@unittest.skipIf(cffi is None, "No cffi")
@ -233,7 +225,7 @@ class TestCffi(AccessTest):
w, h = im.size
for x in range(0, w, 10):
for y in range(0, h, 10):
self.assertEqual(access[(x, y)], caccess[(x, y)])
assert access[(x, y)] == caccess[(x, y)]
# Access an out-of-range pixel
self.assertRaises(
@ -280,11 +272,11 @@ class TestCffi(AccessTest):
for x in range(0, w, 10):
for y in range(0, h, 10):
access[(x, y)] = color
self.assertEqual(color, caccess[(x, y)])
assert color == caccess[(x, y)]
# Attempt to set the value on a read-only image
access = PyAccess.new(im, True)
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
access[(0, 0)] = color
def test_set_vs_c(self):
@ -314,7 +306,7 @@ class TestCffi(AccessTest):
# self._test_set_access(im, 2**13-1)
def test_not_implemented(self):
self.assertIsNone(PyAccess.new(hopper("BGR;15")))
assert PyAccess.new(hopper("BGR;15")) is None
# ref https://github.com/python-pillow/Pillow/pull/2009
def test_reference_counting(self):
@ -325,14 +317,14 @@ class TestCffi(AccessTest):
px = Image.new("L", (size, 1), 0).load()
for i in range(size):
# pixels can contain garbage if image is released
self.assertEqual(px[i, 0], 0)
assert px[i, 0] == 0
def test_p_putpixel_rgb_rgba(self):
for color in [(255, 0, 0), (255, 0, 0, 255)]:
im = Image.new("P", (1, 1), 0)
access = PyAccess.new(im, False)
access.putpixel((0, 0), color)
self.assertEqual(im.convert("RGB").getpixel((0, 0)), (255, 0, 0))
assert im.convert("RGB").getpixel((0, 0)) == (255, 0, 0)
class TestEmbeddable(unittest.TestCase):
@ -387,4 +379,4 @@ int main(int argc, char* argv[])
process = subprocess.Popen(["embed_pil.exe"], env=env)
process.communicate()
self.assertEqual(process.returncode, 0)
assert process.returncode == 0

View File

@ -14,8 +14,8 @@ class TestImageConvert(PillowTestCase):
def test_sanity(self):
def convert(im, mode):
out = im.convert(mode)
self.assertEqual(out.mode, mode)
self.assertEqual(out.size, im.size)
assert out.mode == mode
assert out.size == im.size
modes = (
"1",
@ -57,7 +57,7 @@ class TestImageConvert(PillowTestCase):
def _test_float_conversion(self, im):
orig = im.getpixel((5, 5))
converted = im.convert("F").getpixel((5, 5))
self.assertEqual(orig, converted)
assert orig == converted
def test_8bit(self):
with Image.open("Tests/images/hopper.jpg") as im:
@ -87,11 +87,11 @@ class TestImageConvert(PillowTestCase):
f = self.tempfile("temp.png")
im_l = im.convert("L")
self.assertEqual(im_l.info["transparency"], 0) # undone
assert im_l.info["transparency"] == 0 # undone
im_l.save(f)
im_rgb = im.convert("RGB")
self.assertEqual(im_rgb.info["transparency"], (0, 0, 0)) # undone
assert im_rgb.info["transparency"] == (0, 0, 0) # undone
im_rgb.save(f)
# ref https://github.com/python-pillow/Pillow/issues/664
@ -105,9 +105,9 @@ class TestImageConvert(PillowTestCase):
im_rgba = im.convert("RGBA")
# Assert
self.assertNotIn("transparency", im_rgba.info)
assert "transparency" not in im_rgba.info
# https://github.com/python-pillow/Pillow/issues/2702
self.assertIsNone(im_rgba.palette)
assert im_rgba.palette is None
def test_trns_l(self):
im = hopper("L")
@ -116,15 +116,15 @@ class TestImageConvert(PillowTestCase):
f = self.tempfile("temp.png")
im_rgb = im.convert("RGB")
self.assertEqual(im_rgb.info["transparency"], (128, 128, 128)) # undone
assert im_rgb.info["transparency"] == (128, 128, 128) # undone
im_rgb.save(f)
im_p = im.convert("P")
self.assertIn("transparency", im_p.info)
assert "transparency" in im_p.info
im_p.save(f)
im_p = pytest.warns(UserWarning, im.convert, "P", palette=Image.ADAPTIVE)
self.assertNotIn("transparency", im_p.info)
assert "transparency" not in im_p.info
im_p.save(f)
def test_trns_RGB(self):
@ -134,19 +134,19 @@ class TestImageConvert(PillowTestCase):
f = self.tempfile("temp.png")
im_l = im.convert("L")
self.assertEqual(im_l.info["transparency"], im_l.getpixel((0, 0))) # undone
assert im_l.info["transparency"] == im_l.getpixel((0, 0)) # undone
im_l.save(f)
im_p = im.convert("P")
self.assertIn("transparency", im_p.info)
assert "transparency" in im_p.info
im_p.save(f)
im_rgba = im.convert("RGBA")
self.assertNotIn("transparency", im_rgba.info)
assert "transparency" not in im_rgba.info
im_rgba.save(f)
im_p = pytest.warns(UserWarning, im.convert, "P", palette=Image.ADAPTIVE)
self.assertNotIn("transparency", im_p.info)
assert "transparency" not in im_p.info
im_p.save(f)
def test_gif_with_rgba_palette_to_p(self):
@ -154,7 +154,7 @@ class TestImageConvert(PillowTestCase):
with Image.open("Tests/images/hopper.gif") as im:
im.info["transparency"] = 255
im.load()
self.assertEqual(im.palette.mode, "RGBA")
assert im.palette.mode == "RGBA"
im_p = im.convert("P")
# Should not raise ValueError: unrecognized raw mode
@ -178,10 +178,11 @@ class TestImageConvert(PillowTestCase):
0.212671, 0.715160, 0.072169, 0,
0.019334, 0.119193, 0.950227, 0)
# fmt: on
self.assertNotEqual(im.mode, "RGB")
assert im.mode != "RGB"
# Act / Assert
self.assertRaises(ValueError, im.convert, mode="CMYK", matrix=matrix)
with pytest.raises(ValueError):
im.convert(mode="CMYK", matrix=matrix)
def test_matrix_wrong_mode(self):
# Arrange
@ -192,10 +193,11 @@ class TestImageConvert(PillowTestCase):
0.212671, 0.715160, 0.072169, 0,
0.019334, 0.119193, 0.950227, 0)
# fmt: on
self.assertEqual(im.mode, "L")
assert im.mode == "L"
# Act / Assert
self.assertRaises(ValueError, im.convert, mode="L", matrix=matrix)
with pytest.raises(ValueError):
im.convert(mode="L", matrix=matrix)
def test_matrix_xyz(self):
def matrix_convert(mode):
@ -208,22 +210,22 @@ class TestImageConvert(PillowTestCase):
0.212671, 0.715160, 0.072169, 0,
0.019334, 0.119193, 0.950227, 0)
# fmt: on
self.assertEqual(im.mode, "RGB")
assert im.mode == "RGB"
# Act
# Convert an RGB image to the CIE XYZ colour space
converted_im = im.convert(mode=mode, matrix=matrix)
# Assert
self.assertEqual(converted_im.mode, mode)
self.assertEqual(converted_im.size, im.size)
assert converted_im.mode == mode
assert converted_im.size == im.size
with Image.open("Tests/images/hopper-XYZ.png") as target:
if converted_im.mode == "RGB":
assert_image_similar(converted_im, target, 3)
self.assertEqual(converted_im.info["transparency"], (105, 54, 4))
assert converted_im.info["transparency"] == (105, 54, 4)
else:
assert_image_similar(converted_im, target.getchannel(0), 1)
self.assertEqual(converted_im.info["transparency"], 105)
assert converted_im.info["transparency"] == 105
matrix_convert("RGB")
matrix_convert("L")
@ -237,7 +239,7 @@ class TestImageConvert(PillowTestCase):
0, 1, 0, 0,
0, 0, 1, 0)
# fmt: on
self.assertEqual(im.mode, "RGB")
assert im.mode == "RGB"
# Act
# Convert with an identity matrix

View File

@ -23,7 +23,7 @@ class TestImagingPaste(PillowTestCase):
px[self.size // 2, self.size - 1],
px[self.size - 1, self.size - 1],
]
self.assertEqual(actual, expected)
assert actual == expected
def assert_9points_paste(self, im, im2, mask, expected):
im3 = im.copy()
@ -199,8 +199,8 @@ class TestImagingPaste(PillowTestCase):
hist = im.crop(rect).histogram()
while hist:
head, hist = hist[:256], hist[256:]
self.assertEqual(head[255], 128 * 128)
self.assertEqual(sum(head[:255]), 0)
assert head[255] == 128 * 128
assert sum(head[:255]) == 0
def test_color_mask_1(self):
for mode in ("RGBA", "RGB", "L"):

View File

@ -1,3 +1,4 @@
import pytest
from PIL import Image, ImageMath, ImageMode
from .helper import PillowTestCase, convert_to_comparable
@ -39,51 +40,51 @@ class TestImageReduce(PillowTestCase):
def test_args_factor(self):
im = Image.new("L", (10, 10))
self.assertEqual((4, 4), im.reduce(3).size)
self.assertEqual((4, 10), im.reduce((3, 1)).size)
self.assertEqual((10, 4), im.reduce((1, 3)).size)
assert (4, 4) == im.reduce(3).size
assert (4, 10) == im.reduce((3, 1)).size
assert (10, 4) == im.reduce((1, 3)).size
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(0)
with self.assertRaises(TypeError):
with pytest.raises(TypeError):
im.reduce(2.0)
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce((0, 10))
def test_args_box(self):
im = Image.new("L", (10, 10))
self.assertEqual((5, 5), im.reduce(2, (0, 0, 10, 10)).size)
self.assertEqual((1, 1), im.reduce(2, (5, 5, 6, 6)).size)
assert (5, 5) == im.reduce(2, (0, 0, 10, 10)).size
assert (1, 1) == im.reduce(2, (5, 5, 6, 6)).size
with self.assertRaises(TypeError):
with pytest.raises(TypeError):
im.reduce(2, "stri")
with self.assertRaises(TypeError):
with pytest.raises(TypeError):
im.reduce(2, 2)
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(2, (0, 0, 11, 10))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(2, (0, 0, 10, 11))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(2, (-1, 0, 10, 10))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(2, (0, -1, 10, 10))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(2, (0, 5, 10, 5))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(2, (5, 0, 5, 10))
def test_unsupported_modes(self):
im = Image.new("P", (10, 10))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(3)
im = Image.new("1", (10, 10))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(3)
im = Image.new("I;16", (10, 10))
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
im.reduce(3)
def get_image(self, mode):
@ -109,7 +110,7 @@ class TestImageReduce(PillowTestCase):
box = (11, 13, 146, 164)
reduced = im.reduce(factor, box=box)
reference = im.crop(box).reduce(factor)
self.assertEqual(reduced, reference)
assert reduced == reference
def compare_reduce_with_reference(self, im, factor, average_diff=0.4, max_diff=1):
"""Image.reduce() should look very similar to Image.resize(BOX).
@ -135,13 +136,13 @@ class TestImageReduce(PillowTestCase):
reference.paste(area, (0, 0))
if area_size[0] < reduced.size[0]:
self.assertEqual(reduced.size[0] - area_size[0], 1)
assert reduced.size[0] - area_size[0] == 1
last_column_box = (area_box[2], 0, im.size[0], area_box[3])
last_column = im.resize((1, area_size[1]), Image.BOX, last_column_box)
reference.paste(last_column, (area_size[0], 0))
if area_size[1] < reduced.size[1]:
self.assertEqual(reduced.size[1] - area_size[1], 1)
assert reduced.size[1] - area_size[1] == 1
last_row_box = (0, area_box[3], area_box[2], im.size[1])
last_row = im.resize((area_size[0], 1), Image.BOX, last_row_box)
reference.paste(last_row, (0, area_size[1]))
@ -154,8 +155,8 @@ class TestImageReduce(PillowTestCase):
self.assert_compare_images(reduced, reference, average_diff, max_diff)
def assert_compare_images(self, a, b, max_average_diff, max_diff=255):
self.assertEqual(a.mode, b.mode, "got mode %r, expected %r" % (a.mode, b.mode))
self.assertEqual(a.size, b.size, "got size %r, expected %r" % (a.size, b.size))
assert a.mode == b.mode, "got mode %r, expected %r" % (a.mode, b.mode)
assert a.size == b.size, "got size %r, expected %r" % (a.size, b.size)
a, b = convert_to_comparable(a, b)
@ -167,22 +168,15 @@ class TestImageReduce(PillowTestCase):
average_diff = sum(i * num for i, num in enumerate(ch_hist)) / (
a.size[0] * a.size[1]
)
self.assertGreaterEqual(
max_average_diff,
average_diff,
(
"average pixel value difference {:.4f} > 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(
assert (
max_diff >= last_diff
), "max pixel value difference {} > expected {} for '{}' band".format(
last_diff, max_diff, band
),
)
def test_mode_L(self):

View File

@ -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,

View File

@ -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))

View File

@ -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

View File

@ -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):

View File

@ -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,
}

View File

@ -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,26 +598,31 @@ 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(),
[
assert font.get_variation_names(), [
b"ExtraLight",
b"Light",
b"Regular",
@ -629,20 +632,14 @@ class TestImageFont(PillowTestCase):
b"Black Medium Contrast",
b"Black High Contrast",
b"Default",
],
)
self.assertEqual(
font.get_variation_axes(),
[
]
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(),
[
assert font.get_variation_names() == [
b"20",
b"40",
b"60",
@ -659,22 +656,22 @@ class TestImageFont(PillowTestCase):
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_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")

View File

@ -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)

View File

@ -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"

View File

@ -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,
[
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

View File

@ -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

View File

@ -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")

View File

@ -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()

View File

@ -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)

View File

@ -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))

View File

@ -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()

View File

@ -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)

View File

@ -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,15 +17,9 @@ class TestModeI16(PillowTestCase):
xy = x, y
p1 = pix1[xy]
p2 = pix2[xy]
self.assertEqual(
p1,
p2,
(
"got {!r} from mode {} at {}, expected {!r}".format(
assert p1 == p2, "got {!r} from mode {} at {}, expected {!r}".format(
p1, im1.mode, xy, p2
)
),
)
def test_basic(self):
# PIL 1.1 has limited support for 16-bit image data. Check that
@ -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):

View File

@ -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

View File

@ -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)

View File

@ -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))

View File

@ -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])