Pillow/Tests/test_file_png.py

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

827 lines
28 KiB
Python
Raw Normal View History

from __future__ import annotations
2024-01-20 14:23:03 +03:00
2020-02-22 19:07:04 +03:00
import re
import sys
import warnings
import zlib
from io import BytesIO
from pathlib import Path
2024-02-20 07:41:20 +03:00
from types import ModuleType
2024-03-02 05:12:17 +03:00
from typing import Any, cast
import pytest
2019-10-12 16:29:10 +03:00
from PIL import Image, ImageFile, PngImagePlugin, features
2014-06-10 13:10:47 +04:00
from .helper import (
PillowLeakTestCase,
assert_image,
assert_image_equal,
assert_image_equal_tofile,
hopper,
is_win32,
2021-04-10 00:33:21 +03:00
mark_if_feature_version,
2021-04-10 17:58:01 +03:00
skip_unless_feature,
)
2024-02-20 07:41:20 +03:00
ElementTree: ModuleType | None
try:
from defusedxml import ElementTree
except ImportError:
ElementTree = None
# sample png stream
2014-09-04 13:09:52 +04:00
TEST_PNG_FILE = "Tests/images/hopper.png"
# stuff to create inline PNG images
MAGIC = PngImagePlugin._MAGIC
2014-06-10 13:10:47 +04:00
2024-02-07 11:16:28 +03:00
def chunk(cid: bytes, *data: bytes) -> bytes:
2015-04-24 11:24:52 +03:00
test_file = BytesIO()
PngImagePlugin.putchunk(*(test_file, cid) + data)
return test_file.getvalue()
2018-03-03 12:54:00 +03:00
o32 = PngImagePlugin.o32
2019-06-13 18:54:11 +03:00
IHDR = chunk(b"IHDR", o32(1), o32(1), b"\x08\x02", b"\0\0\0")
IDAT = chunk(b"IDAT")
IEND = chunk(b"IEND")
HEAD = MAGIC + IHDR
TAIL = IDAT + IEND
2014-06-10 13:10:47 +04:00
2024-02-07 11:16:28 +03:00
def load(data: bytes) -> Image.Image:
return Image.open(BytesIO(data))
2014-06-10 13:10:47 +04:00
2024-03-02 05:12:17 +03:00
def roundtrip(im: Image.Image, **options: Any) -> PngImagePlugin.PngImageFile:
out = BytesIO()
im.save(out, "PNG", **options)
out.seek(0)
2024-03-02 05:12:17 +03:00
return cast(PngImagePlugin.PngImageFile, Image.open(out))
@skip_unless_feature("zlib")
2020-03-02 17:02:19 +03:00
class TestFilePng:
2024-02-07 11:16:28 +03:00
def get_chunks(self, filename: str) -> list[bytes]:
2017-12-20 13:27:13 +03:00
chunks = []
with open(filename, "rb") as fp:
fp.read(8)
2017-12-20 14:45:52 +03:00
with PngImagePlugin.PngStream(fp) as png:
while True:
cid, pos, length = png.read()
chunks.append(cid)
try:
s = png.call(cid, pos, length)
except EOFError:
break
png.crc(cid, s)
2017-12-20 13:27:13 +03:00
return chunks
def test_sanity(self, tmp_path: Path) -> None:
2014-06-10 13:10:47 +04:00
# internal version number
assert re.search(
r"\d+(\.\d+){1,3}(\.zlib\-ng)?$", features.version_codec("zlib")
)
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2015-04-24 11:24:52 +03:00
hopper("RGB").save(test_file)
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(test_file) as im:
im.load()
assert im.mode == "RGB"
assert im.size == (128, 128)
assert im.format == "PNG"
assert im.get_format_mimetype() == "image/png"
2023-07-24 10:17:15 +03:00
for mode in ["1", "L", "P", "RGB", "I", "I;16", "I;16B"]:
2019-03-12 09:28:42 +03:00
im = hopper(mode)
im.save(test_file)
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as reloaded:
2024-03-02 07:39:43 +03:00
if mode in ("I", "I;16B"):
2019-11-25 23:03:23 +03:00
reloaded = reloaded.convert(mode)
assert_image_equal(reloaded, im)
def test_invalid_file(self) -> None:
2015-07-03 09:22:56 +03:00
invalid_file = "Tests/images/flower.jpg"
with pytest.raises(SyntaxError):
PngImagePlugin.PngImageFile(invalid_file)
2015-07-03 08:03:25 +03:00
def test_broken(self) -> None:
2014-06-10 13:10:47 +04:00
# Check reading of totally broken files. In this case, the test
# file was checked into Subversion as a text file.
2015-04-24 11:24:52 +03:00
test_file = "Tests/images/broken.png"
with pytest.raises(OSError):
2021-02-11 13:43:54 +03:00
with Image.open(test_file):
pass
def test_bad_text(self) -> None:
2014-06-10 13:10:47 +04:00
# Make sure PIL can read malformed tEXt chunks (@PIL152)
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"tEXt") + TAIL)
assert im.info == {}
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"tEXt", b"spam") + TAIL)
assert im.info == {"spam": ""}
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"tEXt", b"spam\0") + TAIL)
assert im.info == {"spam": ""}
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"tEXt", b"spam\0egg") + TAIL)
assert im.info == {"spam": "egg"}
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"tEXt", b"spam\0egg\0") + TAIL)
assert im.info == {"spam": "egg\x00"}
def test_bad_ztxt(self) -> None:
2014-06-10 13:10:47 +04:00
# Test reading malformed zTXt chunks (python-pillow/Pillow#318)
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"zTXt") + TAIL)
assert im.info == {}
2013-08-20 16:17:17 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"zTXt", b"spam") + TAIL)
assert im.info == {"spam": ""}
2013-08-20 16:17:17 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"zTXt", b"spam\0") + TAIL)
assert im.info == {"spam": ""}
2013-08-20 16:17:17 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"zTXt", b"spam\0\0") + TAIL)
assert im.info == {"spam": ""}
2013-08-20 16:17:17 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"zTXt", b"spam\0\0" + zlib.compress(b"egg")[:1]) + TAIL)
assert im.info == {"spam": ""}
2013-08-20 16:17:17 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"zTXt", b"spam\0\0" + zlib.compress(b"egg")) + TAIL)
assert im.info == {"spam": "egg"}
2013-08-20 16:17:17 +04:00
def test_bad_itxt(self) -> None:
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"iTXt") + TAIL)
assert im.info == {}
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"iTXt", b"spam") + TAIL)
assert im.info == {}
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"iTXt", b"spam\0") + TAIL)
assert im.info == {}
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"iTXt", b"spam\0\x02") + TAIL)
assert im.info == {}
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"iTXt", b"spam\0\0\0foo\0") + TAIL)
assert im.info == {}
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(HEAD + chunk(b"iTXt", b"spam\0\0\0en\0Spam\0egg") + TAIL)
assert im.info == {"spam": "egg"}
assert im.info["spam"].lang == "en"
assert im.info["spam"].tkey == "Spam"
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(
HEAD
+ chunk(b"iTXt", b"spam\0\1\0en\0Spam\0" + zlib.compress(b"egg")[:1])
+ TAIL
)
assert im.info == {"spam": ""}
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(
HEAD
+ chunk(b"iTXt", b"spam\0\1\1en\0Spam\0" + zlib.compress(b"egg"))
+ TAIL
)
assert im.info == {}
2014-07-23 12:09:06 +04:00
2019-06-13 18:54:11 +03:00
im = load(
HEAD
+ chunk(b"iTXt", b"spam\0\1\0en\0Spam\0" + zlib.compress(b"egg"))
+ TAIL
)
assert im.info == {"spam": "egg"}
assert im.info["spam"].lang == "en"
assert im.info["spam"].tkey == "Spam"
2014-07-23 12:09:06 +04:00
def test_interlace(self) -> None:
2015-04-24 11:24:52 +03:00
test_file = "Tests/images/pil123p.png"
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert_image(im, "P", (162, 150))
assert im.info.get("interlace")
2019-11-25 23:03:23 +03:00
im.load()
2015-04-24 11:24:52 +03:00
test_file = "Tests/images/pil123rgba.png"
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert_image(im, "RGBA", (162, 150))
assert im.info.get("interlace")
2019-11-25 23:03:23 +03:00
im.load()
def test_load_transparent_p(self) -> None:
2015-04-24 11:24:52 +03:00
test_file = "Tests/images/pil123p.png"
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert_image(im, "P", (162, 150))
2019-11-25 23:03:23 +03:00
im = im.convert("RGBA")
assert_image(im, "RGBA", (162, 150))
2016-10-02 13:31:53 +03:00
# image has 124 unique alpha values
assert len(im.getchannel("A").getcolors()) == 124
def test_load_transparent_rgb(self) -> None:
2015-04-24 11:24:52 +03:00
test_file = "Tests/images/rgb_trns.png"
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert im.info["transparency"] == (0, 255, 52)
assert_image(im, "RGB", (64, 64))
2019-11-25 23:03:23 +03:00
im = im.convert("RGBA")
assert_image(im, "RGBA", (64, 64))
2013-11-23 04:04:51 +04:00
2014-06-10 13:10:47 +04:00
# image has 876 transparent pixels
assert im.getchannel("A").getcolors()[0][0] == 876
2013-11-23 04:04:51 +04:00
def test_save_p_transparent_palette(self, tmp_path: Path) -> None:
2014-06-10 13:10:47 +04:00
in_file = "Tests/images/pil123p.png"
2019-11-25 23:03:23 +03:00
with Image.open(in_file) as im:
# 'transparency' contains a byte string with the opacity for
# each palette entry
assert len(im.info["transparency"]) == 256
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2019-11-25 23:03:23 +03:00
im.save(test_file)
# check if saved image contains same transparency
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert len(im.info["transparency"]) == 256
assert_image(im, "P", (162, 150))
2019-11-25 23:03:23 +03:00
im = im.convert("RGBA")
assert_image(im, "RGBA", (162, 150))
2016-05-03 21:46:22 +03:00
# image has 124 unique alpha values
assert len(im.getchannel("A").getcolors()) == 124
def test_save_p_single_transparency(self, tmp_path: Path) -> None:
2014-06-10 13:10:47 +04:00
in_file = "Tests/images/p_trns_single.png"
2019-11-25 23:03:23 +03:00
with Image.open(in_file) as im:
# pixel value 164 is full transparent
assert im.info["transparency"] == 164
assert im.getpixel((31, 31)) == 164
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2019-11-25 23:03:23 +03:00
im.save(test_file)
# check if saved image contains same transparency
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert im.info["transparency"] == 164
assert im.getpixel((31, 31)) == 164
assert_image(im, "P", (64, 64))
2019-11-25 23:03:23 +03:00
im = im.convert("RGBA")
assert_image(im, "RGBA", (64, 64))
assert im.getpixel((31, 31)) == (0, 255, 52, 0)
# image has 876 transparent pixels
assert im.getchannel("A").getcolors()[0][0] == 876
def test_save_p_transparent_black(self, tmp_path: Path) -> None:
# check if solid black image with full transparency
# is supported (check for #1838)
im = Image.new("RGBA", (10, 10), (0, 0, 0, 0))
assert im.getcolors() == [(100, (0, 0, 0, 0))]
im = im.convert("P")
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2015-04-24 11:24:52 +03:00
im.save(test_file)
# check if saved image contains same transparency
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert len(im.info["transparency"]) == 256
assert_image(im, "P", (10, 10))
2019-11-25 23:03:23 +03:00
im = im.convert("RGBA")
assert_image(im, "RGBA", (10, 10))
assert im.getcolors() == [(100, (0, 0, 0, 0))]
def test_save_grayscale_transparency(self, tmp_path: Path) -> None:
2024-03-02 07:39:43 +03:00
for mode, num_transparent in {"1": 1994, "L": 559, "I;16": 559}.items():
in_file = "Tests/images/" + mode.split(";")[0].lower() + "_trns.png"
2019-11-25 23:03:23 +03:00
with Image.open(in_file) as im:
assert im.mode == mode
assert im.info["transparency"] == 255
2019-11-25 23:03:23 +03:00
im_rgba = im.convert("RGBA")
assert im_rgba.getchannel("A").getcolors()[0][0] == num_transparent
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
im.save(test_file)
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as test_im:
assert test_im.mode == mode
assert test_im.info["transparency"] == 255
assert_image_equal(im, test_im)
2019-06-13 18:54:11 +03:00
test_im_rgba = test_im.convert("RGBA")
assert test_im_rgba.getchannel("A").getcolors()[0][0] == num_transparent
def test_save_rgb_single_transparency(self, tmp_path: Path) -> None:
2014-06-10 13:10:47 +04:00
in_file = "Tests/images/caption_6_33_22.png"
2019-11-25 23:03:23 +03:00
with Image.open(in_file) as im:
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2019-11-25 23:03:23 +03:00
im.save(test_file)
def test_load_verify(self) -> None:
2014-06-10 13:10:47 +04:00
# Check open/load/verify exception (@PIL150)
2019-11-25 23:03:23 +03:00
with Image.open(TEST_PNG_FILE) as im:
# Assert that there is no unclosed file warning
with warnings.catch_warnings():
im.verify()
2019-11-25 23:03:23 +03:00
with Image.open(TEST_PNG_FILE) as im:
im.load()
with pytest.raises(RuntimeError):
im.verify()
def test_verify_struct_error(self) -> None:
# Check open/load/verify exception (#1755)
# offsets to test, -10: breaks in i32() in read. (OSError)
# -13: breaks in crc, txt chunk.
# -14: malformed chunk
for offset in (-10, -13, -14):
2019-06-13 18:54:11 +03:00
with open(TEST_PNG_FILE, "rb") as f:
test_file = f.read()[:offset]
2019-11-25 23:03:23 +03:00
with Image.open(BytesIO(test_file)) as im:
assert im.fp is not None
with pytest.raises((OSError, SyntaxError)):
im.verify()
def test_verify_ignores_crc_error(self) -> None:
# check ignores crc errors in ancillary chunks
2019-06-13 18:54:11 +03:00
chunk_data = chunk(b"tEXt", b"spam")
broken_crc_chunk_data = chunk_data[:-1] + b"q" # break CRC
image_data = HEAD + broken_crc_chunk_data + TAIL
with pytest.raises(SyntaxError):
PngImagePlugin.PngImageFile(BytesIO(image_data))
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
im = load(image_data)
assert im is not None
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
def test_verify_not_ignores_crc_error_in_required_chunk(self) -> None:
# check does not ignore crc errors in required chunks
2019-06-13 18:54:11 +03:00
image_data = MAGIC + IHDR[:-1] + b"q" + TAIL
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
with pytest.raises(SyntaxError):
PngImagePlugin.PngImageFile(BytesIO(image_data))
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
def test_roundtrip_dpi(self) -> None:
2014-06-10 13:10:47 +04:00
# Check dpi roundtripping
2019-11-25 23:03:23 +03:00
with Image.open(TEST_PNG_FILE) as im:
2021-05-07 13:39:05 +03:00
im = roundtrip(im, dpi=(100.33, 100.33))
assert im.info["dpi"] == (100.33, 100.33)
def test_load_float_dpi(self) -> None:
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(TEST_PNG_FILE) as im:
2021-05-07 13:39:05 +03:00
assert im.info["dpi"] == (95.9866, 95.9866)
2019-03-30 07:03:57 +03:00
def test_roundtrip_text(self) -> None:
2014-06-10 13:10:47 +04:00
# Check text roundtripping
2019-11-25 23:03:23 +03:00
with Image.open(TEST_PNG_FILE) as im:
info = PngImagePlugin.PngInfo()
info.add_text("TXT", "VALUE")
info.add_text("ZIP", "VALUE", zip=True)
2019-11-25 23:03:23 +03:00
im = roundtrip(im, pnginfo=info)
assert im.info == {"TXT": "VALUE", "ZIP": "VALUE"}
assert im.text == {"TXT": "VALUE", "ZIP": "VALUE"}
def test_roundtrip_itxt(self) -> None:
2014-07-23 18:27:51 +04:00
# Check iTXt roundtripping
im = Image.new("RGB", (32, 32))
info = PngImagePlugin.PngInfo()
info.add_itxt("spam", "Eggs", "en", "Spam")
2019-06-13 18:54:11 +03:00
info.add_text("eggs", PngImagePlugin.iTXt("Spam", "en", "Eggs"), zip=True)
2014-07-23 18:27:51 +04:00
im = roundtrip(im, pnginfo=info)
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"
2014-07-23 18:27:51 +04:00
def test_nonunicode_text(self) -> None:
# Check so that non-Unicode text is saved as a tEXt rather than iTXt
im = Image.new("RGB", (32, 32))
info = PngImagePlugin.PngInfo()
info.add_text("Text", "Ascii")
im = roundtrip(im, pnginfo=info)
assert isinstance(im.info["Text"], str)
def test_unicode_text(self) -> None:
2019-10-07 15:34:12 +03:00
# Check preservation of non-ASCII characters
2024-02-07 11:16:28 +03:00
def rt_text(value: str) -> None:
im = Image.new("RGB", (32, 32))
info = PngImagePlugin.PngInfo()
info.add_text("Text", value)
im = roundtrip(im, pnginfo=info)
assert im.info == {"Text": value}
2019-09-26 15:12:28 +03:00
rt_text(" Aa" + chr(0xA0) + chr(0xC4) + chr(0xFF)) # Latin1
rt_text(chr(0x400) + chr(0x472) + chr(0x4FF)) # Cyrillic
# CJK:
rt_text(chr(0x4E00) + chr(0x66F0) + chr(0x9FBA) + chr(0x3042) + chr(0xAC00))
rt_text("A" + chr(0xC4) + chr(0x472) + chr(0x3042)) # Combined
def test_scary(self) -> None:
2014-06-10 13:10:47 +04:00
# Check reading of evil PNG file. For information, see:
# http://scary.beasts.org/security/CESA-2004-001.txt
# The first byte is removed from pngtest_bad.png
# to avoid classification as malware.
2019-06-13 18:54:11 +03:00
with open("Tests/images/pngtest_bad.png.bin", "rb") as fd:
data = b"\x89" + fd.read()
2014-06-10 13:10:47 +04:00
pngfile = BytesIO(data)
with pytest.raises(OSError):
2021-02-11 13:43:54 +03:00
with Image.open(pngfile):
pass
def test_trns_rgb(self) -> None:
2014-06-10 13:10:47 +04:00
# Check writing and reading of tRNS chunks for RGB images.
# Independent file sample provided by Sebastian Spaeth.
2015-04-24 11:24:52 +03:00
test_file = "Tests/images/caption_6_33_22.png"
2019-11-25 23:03:23 +03:00
with Image.open(test_file) as im:
assert im.info["transparency"] == (248, 248, 248)
2019-11-25 23:03:23 +03:00
# check saving transparency by default
im = roundtrip(im)
assert im.info["transparency"] == (248, 248, 248)
2014-06-10 13:10:47 +04:00
im = roundtrip(im, transparency=(0, 1, 2))
assert im.info["transparency"] == (0, 1, 2)
def test_trns_p(self, tmp_path: Path) -> None:
2014-06-10 13:10:47 +04:00
# Check writing a transparency of 0, issue #528
2019-06-13 18:54:11 +03:00
im = hopper("P")
im.info["transparency"] = 0
2020-03-02 17:02:19 +03:00
f = str(tmp_path / "temp.png")
2014-06-10 13:10:47 +04:00
im.save(f)
2019-11-25 23:03:23 +03:00
with Image.open(f) as im2:
assert "transparency" in im2.info
2014-03-01 04:29:34 +04:00
assert_image_equal(im2.convert("RGBA"), im.convert("RGBA"))
2014-03-01 04:29:34 +04:00
def test_trns_null(self) -> None:
# Check reading images with null tRNS value, issue #1239
test_file = "Tests/images/tRNS_null_1x1.png"
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(test_file) as im:
assert im.info["transparency"] == 0
def test_save_icc_profile(self) -> None:
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open("Tests/images/icc_profile_none.png") as im:
assert im.info["icc_profile"] is None
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open("Tests/images/icc_profile.png") as with_icc:
expected_icc = with_icc.info["icc_profile"]
2016-05-12 20:28:58 +03:00
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
im = roundtrip(im, icc_profile=expected_icc)
assert im.info["icc_profile"] == expected_icc
2016-05-12 20:28:58 +03:00
def test_discard_icc_profile(self) -> None:
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/icc_profile.png") as im:
2021-03-10 12:16:49 +03:00
assert "icc_profile" in im.info
2019-11-25 23:03:23 +03:00
im = roundtrip(im, icc_profile=None)
assert "icc_profile" not in im.info
def test_roundtrip_icc_profile(self) -> None:
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/icc_profile.png") as im:
expected_icc = im.info["icc_profile"]
2019-11-25 23:03:23 +03:00
im = roundtrip(im)
assert im.info["icc_profile"] == expected_icc
def test_roundtrip_no_icc_profile(self) -> None:
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/icc_profile_none.png") as im:
assert im.info["icc_profile"] is None
2016-05-12 20:28:58 +03:00
2019-11-25 23:03:23 +03:00
im = roundtrip(im)
assert "icc_profile" not in im.info
2016-05-12 20:28:58 +03:00
def test_repr_png(self) -> None:
im = hopper()
2019-11-25 23:03:23 +03:00
with Image.open(BytesIO(im._repr_png_())) as repr_png:
assert repr_png.format == "PNG"
assert_image_equal(im, repr_png)
def test_repr_png_error_returns_none(self) -> None:
im = hopper("F")
assert im._repr_png_() is None
def test_chunk_order(self, tmp_path: Path) -> None:
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/icc_profile.png") as im:
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2019-11-25 23:03:23 +03:00
im.convert("P").save(test_file, dpi=(100, 100))
2017-12-20 13:27:13 +03:00
chunks = self.get_chunks(test_file)
# https://www.w3.org/TR/PNG/#5ChunkOrdering
# IHDR - shall be first
assert chunks.index(b"IHDR") == 0
# PLTE - before first IDAT
assert chunks.index(b"PLTE") < chunks.index(b"IDAT")
# iCCP - before PLTE and IDAT
assert chunks.index(b"iCCP") < chunks.index(b"PLTE")
assert chunks.index(b"iCCP") < chunks.index(b"IDAT")
# tRNS - after PLTE, before IDAT
assert chunks.index(b"tRNS") > chunks.index(b"PLTE")
assert chunks.index(b"tRNS") < chunks.index(b"IDAT")
# pHYs - before IDAT
assert chunks.index(b"pHYs") < chunks.index(b"IDAT")
def test_getchunks(self) -> None:
2017-09-01 13:36:51 +03:00
im = hopper()
chunks = PngImagePlugin.getchunks(im)
assert len(chunks) == 3
2017-09-01 13:36:51 +03:00
def test_read_private_chunks(self) -> None:
2021-02-02 15:39:53 +03:00
with Image.open("Tests/images/exif.png") as im:
assert im.private_chunks == [(b"orNT", b"\x01")]
def test_roundtrip_private_chunk(self) -> None:
# Check private chunk roundtripping
with Image.open(TEST_PNG_FILE) as im:
info = PngImagePlugin.PngInfo()
info.add(b"prIV", b"VALUE")
info.add(b"atEC", b"VALUE2")
info.add(b"prIV", b"VALUE3", True)
im = roundtrip(im, pnginfo=info)
assert im.private_chunks == [(b"prIV", b"VALUE"), (b"atEC", b"VALUE2")]
im.load()
assert im.private_chunks == [
(b"prIV", b"VALUE"),
(b"atEC", b"VALUE2"),
(b"prIV", b"VALUE3", True),
]
def test_textual_chunks_after_idat(self) -> None:
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/hopper.png") as im:
assert "comment" in im.text
2019-11-25 23:03:23 +03:00
for k, v in {
"date:create": "2014-09-04T09:37:08+03:00",
"date:modify": "2014-09-04T09:37:08+03:00",
}.items():
assert im.text[k] == v
# Raises a SyntaxError in load_end
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/broken_data_stream.png") as im:
with pytest.raises(OSError):
assert isinstance(im.text, dict)
# Raises a UnicodeDecodeError in load_end
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/truncated_image.png") as im:
# The file is truncated
with pytest.raises(OSError):
im.text()
2019-11-25 23:03:23 +03:00
ImageFile.LOAD_TRUNCATED_IMAGES = True
assert isinstance(im.text, dict)
2019-11-25 23:03:23 +03:00
ImageFile.LOAD_TRUNCATED_IMAGES = False
2019-01-03 11:13:19 +03:00
# Raises an EOFError in load_end
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/hopper_idat_after_image_end.png") as im:
assert im.text == {"TXT": "VALUE", "ZIP": "VALUE"}
2019-01-03 11:13:19 +03:00
def test_unknown_compression_method(self) -> None:
with pytest.raises(SyntaxError, match="Unknown compression method"):
PngImagePlugin.PngImageFile("Tests/images/unknown_compression_method.png")
def test_padded_idat(self) -> None:
# This image has been manually hexedited
# so that the IDAT chunk has padding at the end
# Set MAXBLOCK to the length of the actual data
# so that the decoder finishes reading before the chunk ends
MAXBLOCK = ImageFile.MAXBLOCK
ImageFile.MAXBLOCK = 45
ImageFile.LOAD_TRUNCATED_IMAGES = True
with Image.open("Tests/images/padded_idat.png") as im:
im.load()
ImageFile.MAXBLOCK = MAXBLOCK
ImageFile.LOAD_TRUNCATED_IMAGES = False
assert_image_equal_tofile(im, "Tests/images/bw_gradient.png")
@pytest.mark.parametrize(
"cid", (b"IHDR", b"sRGB", b"pHYs", b"acTL", b"fcTL", b"fdAT")
)
2024-02-07 11:16:28 +03:00
def test_truncated_chunks(self, cid: bytes) -> None:
fp = BytesIO()
with PngImagePlugin.PngStream(fp) as png:
with pytest.raises(ValueError):
png.call(cid, 0, 0)
ImageFile.LOAD_TRUNCATED_IMAGES = True
png.call(cid, 0, 0)
ImageFile.LOAD_TRUNCATED_IMAGES = False
def test_specify_bits(self, tmp_path: Path) -> None:
im = hopper("P")
out = str(tmp_path / "temp.png")
im.save(out, bits=4)
with Image.open(out) as reloaded:
assert len(reloaded.png.im_palette[1]) == 48
def test_plte_length(self, tmp_path: Path) -> None:
im = Image.new("P", (1, 1))
im.putpalette((1, 1, 1))
out = str(tmp_path / "temp.png")
im.save(str(tmp_path / "temp.png"))
with Image.open(out) as reloaded:
assert len(reloaded.png.im_palette[1]) == 3
def test_getxmp(self) -> None:
2021-06-12 06:57:14 +03:00
with Image.open("Tests/images/color_snakes.png") as im:
if ElementTree is None:
2023-10-06 09:31:06 +03:00
with pytest.warns(
UserWarning,
match="XMP data cannot be read without defusedxml dependency",
):
assert im.getxmp() == {}
else:
xmp = im.getxmp()
description = xmp["xmpmeta"]["RDF"]["Description"]
assert description["PixelXDimension"] == "10"
assert description["subject"]["Seq"] is None
2021-06-12 06:57:14 +03:00
def test_exif(self) -> None:
# With an EXIF chunk
with Image.open("Tests/images/exif.png") as im:
2020-03-26 13:21:40 +03:00
exif = im._getexif()
assert exif[274] == 1
# With an ImageMagick zTXt chunk
with Image.open("Tests/images/exif_imagemagick.png") as im:
exif = im._getexif()
assert exif[274] == 1
# Assert that info still can be extracted
# when the image is no longer a PngImageFile instance
exif = im.copy().getexif()
assert exif[274] == 1
# With a tEXt chunk
with Image.open("Tests/images/exif_text.png") as im:
exif = im._getexif()
assert exif[274] == 1
# With XMP tags
2020-04-16 14:05:34 +03:00
with Image.open("Tests/images/xmp_tags_orientation.png") as im:
exif = im.getexif()
assert exif[274] == 3
def test_exif_save(self, tmp_path: Path) -> None:
2022-12-23 04:10:36 +03:00
# Test exif is not saved from info
test_file = str(tmp_path / "temp.png")
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/exif.png") as im:
im.save(test_file)
2022-12-23 04:10:36 +03:00
with Image.open(test_file) as reloaded:
assert reloaded._getexif() is None
# Test passing in exif
with Image.open("Tests/images/exif.png") as im:
im.save(test_file, exif=im.getexif())
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(test_file) as reloaded:
exif = reloaded._getexif()
assert exif[274] == 1
2021-04-10 17:58:01 +03:00
@mark_if_feature_version(
pytest.mark.valgrind_known_error, "libjpeg_turbo", "2.0", reason="Known Failing"
)
def test_exif_from_jpg(self, tmp_path: Path) -> None:
2019-11-25 23:03:23 +03:00
with Image.open("Tests/images/pil_sample_rgb.jpg") as im:
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2022-12-23 04:10:36 +03:00
im.save(test_file, exif=im.getexif())
2019-02-23 05:30:38 +03:00
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(test_file) as reloaded:
exif = reloaded._getexif()
assert exif[305] == "Adobe Photoshop CS Macintosh"
2019-02-23 05:30:38 +03:00
def test_exif_argument(self, tmp_path: Path) -> None:
2019-11-25 23:03:23 +03:00
with Image.open(TEST_PNG_FILE) as im:
2020-03-02 17:02:19 +03:00
test_file = str(tmp_path / "temp.png")
2019-11-25 23:03:23 +03:00
im.save(test_file, exif=b"exifstring")
2019-02-23 05:30:38 +03:00
Improve handling of file resources Follow Python's file object semantics. User code is responsible for closing resources (usually through a context manager) in a deterministic way. To achieve this, remove __del__ functions. These functions used to closed open file handlers in an attempt to silence Python ResourceWarnings. However, using __del__ has the following drawbacks: - __del__ isn't called until the object's reference count reaches 0. Therefore, resource handlers remain open or in use longer than necessary. - The __del__ method isn't guaranteed to execute on system exit. See the Python documentation: https://docs.python.org/3/reference/datamodel.html#object.__del__ > It is not guaranteed that __del__() methods are called for objects > that still exist when the interpreter exits. - Exceptions that occur inside __del__ are ignored instead of raised. This has the potential of hiding bugs. This is also in the Python documentation: > Warning: Due to the precarious circumstances under which __del__() > methods are invoked, exceptions that occur during their execution > are ignored, and a warning is printed to sys.stderr instead. Instead, always close resource handlers when they are no longer in use. This will close the file handler at a specified point in the user's code and not wait until the interpreter chooses to. It is always guaranteed to run. And, if an exception occurs while closing the file handler, the bug will not be ignored. Now, when code receives a ResourceWarning, it will highlight an area that is mishandling resources. It should not simply be silenced, but fixed by closing resources with a context manager. All warnings that were emitted during tests have been cleaned up. To enable warnings, I passed the `-Wa` CLI option to Python. This exposed some mishandling of resources in ImageFile.__init__() and SpiderImagePlugin.loadImageSeries(), they too were fixed.
2019-05-25 19:30:58 +03:00
with Image.open(test_file) as reloaded:
assert reloaded.info["exif"] == b"Exif\x00\x00exifstring"
2019-02-23 05:30:38 +03:00
def test_tell(self) -> None:
with Image.open(TEST_PNG_FILE) as im:
assert im.tell() == 0
def test_seek(self) -> None:
2020-04-01 22:32:14 +03:00
with Image.open(TEST_PNG_FILE) as im:
im.seek(0)
with pytest.raises(EOFError):
im.seek(1)
@pytest.mark.parametrize("buffer", (True, False))
2024-02-07 11:16:28 +03:00
def test_save_stdout(self, buffer: bool) -> None:
old_stdout = sys.stdout
if buffer:
class MyStdOut:
buffer = BytesIO()
mystdout = MyStdOut()
else:
mystdout = BytesIO()
sys.stdout = mystdout
with Image.open(TEST_PNG_FILE) as im:
im.save(sys.stdout, "PNG")
# Reset stdout
sys.stdout = old_stdout
if buffer:
mystdout = mystdout.buffer
2021-11-25 15:16:07 +03:00
with Image.open(mystdout) as reloaded:
assert_image_equal_tofile(reloaded, TEST_PNG_FILE)
def test_truncated_end_chunk(self) -> None:
with Image.open("Tests/images/truncated_end_chunk.png") as im:
with pytest.raises(OSError):
im.load()
ImageFile.LOAD_TRUNCATED_IMAGES = True
try:
with Image.open("Tests/images/truncated_end_chunk.png") as im:
2024-01-16 10:39:33 +03:00
assert_image_equal_tofile(im, "Tests/images/hopper.png")
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False
2014-01-22 08:50:54 +04:00
2020-03-02 17:02:19 +03:00
@pytest.mark.skipif(is_win32(), reason="Requires Unix or macOS")
@skip_unless_feature("zlib")
class TestTruncatedPngPLeaks(PillowLeakTestCase):
2019-06-13 18:54:11 +03:00
mem_limit = 2 * 1024 # max increase in K
iterations = 100 # Leak is 56k/iteration, this will leak 5.6megs
def test_leak_load(self) -> None:
2019-06-13 18:54:11 +03:00
with open("Tests/images/hopper.png", "rb") as f:
DATA = BytesIO(f.read(16 * 1024))
ImageFile.LOAD_TRUNCATED_IMAGES = True
with Image.open(DATA) as im:
im.load()
def core() -> None:
with Image.open(DATA) as im:
im.load()
try:
self._test_leak(core)
finally:
ImageFile.LOAD_TRUNCATED_IMAGES = False