mirror of
https://github.com/python-pillow/Pillow.git
synced 2024-12-26 18:06:18 +03:00
4f185329f4
This adds a new test decorator: skip_unless_feature(). The argument is the same as passed to features.check(). If the feature is not supported, the test will be skipped. This removes several kinds of boilerplate copied and pasted around tests so test feature checking is handled and displayed more consistently. Refs #4193
210 lines
7.0 KiB
Python
210 lines
7.0 KiB
Python
from io import BytesIO
|
|
|
|
import pytest
|
|
from PIL import Image, ImageFile, Jpeg2KImagePlugin
|
|
|
|
from .helper import (
|
|
PillowTestCase,
|
|
assert_image_equal,
|
|
assert_image_similar,
|
|
is_big_endian,
|
|
on_ci,
|
|
skip_unless_feature,
|
|
)
|
|
|
|
test_card = Image.open("Tests/images/test-card.png")
|
|
test_card.load()
|
|
|
|
# OpenJPEG 2.0.0 outputs this debugging message sometimes; we should
|
|
# ignore it---it doesn't represent a test failure.
|
|
# 'Not enough memory to handle tile data'
|
|
|
|
|
|
@skip_unless_feature("jpg_2000")
|
|
class TestFileJpeg2k(PillowTestCase):
|
|
def roundtrip(self, im, **options):
|
|
out = BytesIO()
|
|
im.save(out, "JPEG2000", **options)
|
|
test_bytes = out.tell()
|
|
out.seek(0)
|
|
im = Image.open(out)
|
|
im.bytes = test_bytes # for testing only
|
|
im.load()
|
|
return im
|
|
|
|
def test_sanity(self):
|
|
# Internal version number
|
|
self.assertRegex(Image.core.jp2klib_version, r"\d+\.\d+\.\d+$")
|
|
|
|
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")
|
|
|
|
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")
|
|
|
|
def test_invalid_file(self):
|
|
invalid_file = "Tests/images/flower.jpg"
|
|
|
|
self.assertRaises(SyntaxError, Jpeg2KImagePlugin.Jpeg2KImageFile, invalid_file)
|
|
|
|
def test_bytesio(self):
|
|
with open("Tests/images/test-card-lossless.jp2", "rb") as f:
|
|
data = BytesIO(f.read())
|
|
with Image.open(data) as im:
|
|
im.load()
|
|
assert_image_similar(im, test_card, 1.0e-3)
|
|
|
|
# These two test pre-written JPEG 2000 files that were not written with
|
|
# PIL (they were made using Adobe Photoshop)
|
|
|
|
def test_lossless(self):
|
|
with Image.open("Tests/images/test-card-lossless.jp2") as im:
|
|
im.load()
|
|
outfile = self.tempfile("temp_test-card.png")
|
|
im.save(outfile)
|
|
assert_image_similar(im, test_card, 1.0e-3)
|
|
|
|
def test_lossy_tiled(self):
|
|
with Image.open("Tests/images/test-card-lossy-tiled.jp2") as im:
|
|
im.load()
|
|
assert_image_similar(im, test_card, 2.0)
|
|
|
|
def test_lossless_rt(self):
|
|
im = self.roundtrip(test_card)
|
|
assert_image_equal(im, test_card)
|
|
|
|
def test_lossy_rt(self):
|
|
im = self.roundtrip(test_card, quality_layers=[20])
|
|
assert_image_similar(im, test_card, 2.0)
|
|
|
|
def test_tiled_rt(self):
|
|
im = self.roundtrip(test_card, tile_size=(128, 128))
|
|
assert_image_equal(im, test_card)
|
|
|
|
def test_tiled_offset_rt(self):
|
|
im = self.roundtrip(
|
|
test_card, tile_size=(128, 128), tile_offset=(0, 0), offset=(32, 32)
|
|
)
|
|
assert_image_equal(im, test_card)
|
|
|
|
def test_tiled_offset_too_small(self):
|
|
with self.assertRaises(ValueError):
|
|
self.roundtrip(
|
|
test_card, tile_size=(128, 128), tile_offset=(0, 0), offset=(128, 32)
|
|
)
|
|
|
|
def test_irreversible_rt(self):
|
|
im = self.roundtrip(test_card, irreversible=True, quality_layers=[20])
|
|
assert_image_similar(im, test_card, 2.0)
|
|
|
|
def test_prog_qual_rt(self):
|
|
im = self.roundtrip(test_card, quality_layers=[60, 40, 20], progression="LRCP")
|
|
assert_image_similar(im, test_card, 2.0)
|
|
|
|
def test_prog_res_rt(self):
|
|
im = self.roundtrip(test_card, num_resolutions=8, progression="RLCP")
|
|
assert_image_equal(im, test_card)
|
|
|
|
def test_reduce(self):
|
|
with Image.open("Tests/images/test-card-lossless.jp2") as im:
|
|
im.reduce = 2
|
|
im.load()
|
|
self.assertEqual(im.size, (160, 120))
|
|
|
|
def test_layers_type(self):
|
|
outfile = self.tempfile("temp_layers.jp2")
|
|
for quality_layers in [[100, 50, 10], (100, 50, 10), None]:
|
|
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
|
|
)
|
|
|
|
def test_layers(self):
|
|
out = BytesIO()
|
|
test_card.save(
|
|
out, "JPEG2000", quality_layers=[100, 50, 10], progression="LRCP"
|
|
)
|
|
out.seek(0)
|
|
|
|
with Image.open(out) as im:
|
|
im.layers = 1
|
|
im.load()
|
|
assert_image_similar(im, test_card, 13)
|
|
|
|
out.seek(0)
|
|
with Image.open(out) as im:
|
|
im.layers = 3
|
|
im.load()
|
|
assert_image_similar(im, test_card, 0.4)
|
|
|
|
def test_rgba(self):
|
|
# Arrange
|
|
with Image.open("Tests/images/rgb_trns_ycbc.j2k") as j2k:
|
|
with Image.open("Tests/images/rgb_trns_ycbc.jp2") as jp2:
|
|
|
|
# Act
|
|
j2k.load()
|
|
jp2.load()
|
|
|
|
# Assert
|
|
self.assertEqual(j2k.mode, "RGBA")
|
|
self.assertEqual(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")
|
|
|
|
with Image.open("Tests/images/16bit.cropped.jp2") as jp2:
|
|
jp2.load()
|
|
self.assertEqual(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):
|
|
with Image.open("Tests/images/16bit.cropped.tif") as tiff_16bit:
|
|
with Image.open("Tests/images/16bit.cropped.jp2") as jp2:
|
|
assert_image_similar(jp2, tiff_16bit, 1e-3)
|
|
|
|
@pytest.mark.xfail(is_big_endian() and on_ci(), reason="Fails on big-endian")
|
|
def test_16bit_monochrome_j2k_like_tiff(self):
|
|
with Image.open("Tests/images/16bit.cropped.tif") as tiff_16bit:
|
|
with Image.open("Tests/images/16bit.cropped.j2k") as j2k:
|
|
assert_image_similar(j2k, tiff_16bit, 1e-3)
|
|
|
|
def test_16bit_j2k_roundtrips(self):
|
|
with Image.open("Tests/images/16bit.cropped.j2k") as j2k:
|
|
im = self.roundtrip(j2k)
|
|
assert_image_equal(im, j2k)
|
|
|
|
def test_16bit_jp2_roundtrips(self):
|
|
with Image.open("Tests/images/16bit.cropped.jp2") as jp2:
|
|
im = self.roundtrip(jp2)
|
|
assert_image_equal(im, jp2)
|
|
|
|
def test_unbound_local(self):
|
|
# prepatch, a malformed jp2 file could cause an UnboundLocalError
|
|
# exception.
|
|
with self.assertRaises(IOError):
|
|
Image.open("Tests/images/unbound_variable.jp2")
|
|
|
|
def test_parser_feed(self):
|
|
# Arrange
|
|
with open("Tests/images/test-card-lossless.jp2", "rb") as f:
|
|
data = f.read()
|
|
|
|
# Act
|
|
p = ImageFile.Parser()
|
|
p.feed(data)
|
|
|
|
# Assert
|
|
self.assertEqual(p.image.size, (640, 480))
|