mirror of
https://github.com/python-pillow/Pillow.git
synced 2024-11-11 12:17:14 +03:00
4de5477b61
With the introduction and use of pytest, it is simple and easy to
execute specific tests in isolation through documented command line
arguments. Either by specifying the module path or through the `-k
EXPRESSION` argument. There is no longer any need to provide the
boilerplate:
if __name__ == '__main__':
unittest.main()
To every test file. It is simply noise.
The pattern remains in test files that aren't named with `test_*` as
those files are not discovered and executed by pytest by default.
213 lines
6.6 KiB
Python
213 lines
6.6 KiB
Python
from .helper import PillowTestCase
|
|
|
|
from PIL import Image, Jpeg2KImagePlugin
|
|
from io import BytesIO
|
|
|
|
codecs = dir(Image.core)
|
|
|
|
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'
|
|
|
|
|
|
class TestFileJpeg2k(PillowTestCase):
|
|
|
|
def setUp(self):
|
|
if "jpeg2k_encoder" not in codecs or "jpeg2k_decoder" not in codecs:
|
|
self.skipTest('JPEG 2000 support not available')
|
|
|
|
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+$')
|
|
|
|
im = Image.open('Tests/images/test-card-lossless.jp2')
|
|
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):
|
|
im = Image.open('Tests/images/balloon.jpf')
|
|
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())
|
|
im = Image.open(data)
|
|
im.load()
|
|
self.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):
|
|
im = Image.open('Tests/images/test-card-lossless.jp2')
|
|
im.load()
|
|
outfile = self.tempfile('temp_test-card.png')
|
|
im.save(outfile)
|
|
self.assert_image_similar(im, test_card, 1.0e-3)
|
|
|
|
def test_lossy_tiled(self):
|
|
im = Image.open('Tests/images/test-card-lossy-tiled.jp2')
|
|
im.load()
|
|
self.assert_image_similar(im, test_card, 2.0)
|
|
|
|
def test_lossless_rt(self):
|
|
im = self.roundtrip(test_card)
|
|
self.assert_image_equal(im, test_card)
|
|
|
|
def test_lossy_rt(self):
|
|
im = self.roundtrip(test_card, quality_layers=[20])
|
|
self.assert_image_similar(im, test_card, 2.0)
|
|
|
|
def test_tiled_rt(self):
|
|
im = self.roundtrip(test_card, tile_size=(128, 128))
|
|
self.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))
|
|
self.assert_image_equal(im, test_card)
|
|
|
|
def test_irreversible_rt(self):
|
|
im = self.roundtrip(test_card, irreversible=True, quality_layers=[20])
|
|
self.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')
|
|
self.assert_image_similar(im, test_card, 2.0)
|
|
|
|
def test_prog_res_rt(self):
|
|
im = self.roundtrip(test_card, num_resolutions=8, progression='RLCP')
|
|
self.assert_image_equal(im, test_card)
|
|
|
|
def test_reduce(self):
|
|
im = Image.open('Tests/images/test-card-lossless.jp2')
|
|
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)
|
|
|
|
im = Image.open(out)
|
|
im.layers = 1
|
|
im.load()
|
|
self.assert_image_similar(im, test_card, 13)
|
|
|
|
out.seek(0)
|
|
im = Image.open(out)
|
|
im.layers = 3
|
|
im.load()
|
|
self.assert_image_similar(im, test_card, 0.4)
|
|
|
|
def test_rgba(self):
|
|
# Arrange
|
|
j2k = Image.open('Tests/images/rgb_trns_ycbc.j2k')
|
|
jp2 = Image.open('Tests/images/rgb_trns_ycbc.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):
|
|
|
|
j2k = Image.open('Tests/images/16bit.cropped.j2k')
|
|
jp2 = Image.open('Tests/images/16bit.cropped.jp2')
|
|
|
|
j2k.load()
|
|
jp2.load()
|
|
|
|
self.assertEqual(j2k.mode, 'I;16')
|
|
self.assertEqual(jp2.mode, 'I;16')
|
|
|
|
def test_16bit_monochrome_jp2_like_tiff(self):
|
|
|
|
tiff_16bit = Image.open('Tests/images/16bit.cropped.tif')
|
|
jp2 = Image.open('Tests/images/16bit.cropped.jp2')
|
|
self.assert_image_similar(jp2, tiff_16bit, 1e-3)
|
|
|
|
def test_16bit_monochrome_j2k_like_tiff(self):
|
|
|
|
tiff_16bit = Image.open('Tests/images/16bit.cropped.tif')
|
|
j2k = Image.open('Tests/images/16bit.cropped.j2k')
|
|
self.assert_image_similar(j2k, tiff_16bit, 1e-3)
|
|
|
|
def test_16bit_j2k_roundtrips(self):
|
|
|
|
j2k = Image.open('Tests/images/16bit.cropped.j2k')
|
|
im = self.roundtrip(j2k)
|
|
self.assert_image_equal(im, j2k)
|
|
|
|
def test_16bit_jp2_roundtrips(self):
|
|
|
|
jp2 = Image.open('Tests/images/16bit.cropped.jp2')
|
|
im = self.roundtrip(jp2)
|
|
self.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
|
|
from PIL import ImageFile
|
|
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))
|