#2723

pending completion

Build # #2723

Build Type

push

github-actions

Committed by

hugovk

Commit Message

Test on new Travis CPUs https://blog.travis-ci.com/2019-11-12-multi-cpu-architecture-ibm-power-ibm-z

Run Details

18 of 18 new or added lines in 5 files covered. (100.0%)

35146 of 40395 relevant lines covered (87.01%)

202893.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.3

/Tests/test_file_jpeg2k.py

from io import BytesIO

import pytest
from PIL import Image, Jpeg2KImagePlugin

from .helper import PillowTestCase, is_big_endian, on_ci

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+$")

        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()
            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):
        with Image.open("Tests/images/test-card-lossless.jp2") as im:
            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):
        with Image.open("Tests/images/test-card-lossy-tiled.jp2") as im:
            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_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])
        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):
        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()
            self.assert_image_similar(im, test_card, 13)

        out.seek(0)
        with Image.open(out) as im:
            im.layers = 3
            im.load()
            self.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:
                self.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:
                self.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)
            self.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)
            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))

1	from io import BytesIO	1✔
2
3	import pytest	1✔
4	from PIL import Image, Jpeg2KImagePlugin	1✔
5
6	from .helper import PillowTestCase, is_big_endian, on_ci	1✔
7
8	codecs = dir(Image.core)	1✔
9
10	test_card = Image.open("Tests/images/test-card.png")	1✔
11	test_card.load()	1✔
12
13	# OpenJPEG 2.0.0 outputs this debugging message sometimes; we should
14	# ignore it---it doesn't represent a test failure.
15	# 'Not enough memory to handle tile data'
16
17
18	class TestFileJpeg2k(PillowTestCase):	1✔
19	def setUp(self):	1✔
20	if "jpeg2k_encoder" not in codecs or "jpeg2k_decoder" not in codecs:	1✔
21	self.skipTest("JPEG 2000 support not available")	×
22
23	def roundtrip(self, im, **options):	1✔
24	out = BytesIO()	1✔
25	im.save(out, "JPEG2000", **options)	1✔
26	test_bytes = out.tell()	1✔
27	out.seek(0)	1✔
28	im = Image.open(out)	1✔
29	im.bytes = test_bytes # for testing only	1✔
30	im.load()	1✔
31	return im	1✔
32
33	def test_sanity(self):	1✔
34	# Internal version number
35	self.assertRegex(Image.core.jp2klib_version, r"\d+\.\d+\.\d+$")	1✔
36
37	with Image.open("Tests/images/test-card-lossless.jp2") as im:	1✔
38	px = im.load()	1✔
39	self.assertEqual(px[0, 0], (0, 0, 0))	1✔
40	self.assertEqual(im.mode, "RGB")	1✔
41	self.assertEqual(im.size, (640, 480))	1✔
42	self.assertEqual(im.format, "JPEG2000")	1✔
43	self.assertEqual(im.get_format_mimetype(), "image/jp2")	1✔
44
45	def test_jpf(self):	1✔
46	with Image.open("Tests/images/balloon.jpf") as im:	1✔
47	self.assertEqual(im.format, "JPEG2000")	1✔
48	self.assertEqual(im.get_format_mimetype(), "image/jpx")	1✔
49
50	def test_invalid_file(self):	1✔
51	invalid_file = "Tests/images/flower.jpg"	1✔
52
53	self.assertRaises(SyntaxError, Jpeg2KImagePlugin.Jpeg2KImageFile, invalid_file)	1✔
54
55	def test_bytesio(self):	1✔
56	with open("Tests/images/test-card-lossless.jp2", "rb") as f:	1✔
57	data = BytesIO(f.read())	1✔
58	with Image.open(data) as im:	1✔
59	im.load()	1✔
60	self.assert_image_similar(im, test_card, 1.0e-3)	1✔
61
62	# These two test pre-written JPEG 2000 files that were not written with
63	# PIL (they were made using Adobe Photoshop)
64
65	def test_lossless(self):	1✔
66	with Image.open("Tests/images/test-card-lossless.jp2") as im:	1✔
67	im.load()	1✔
68	outfile = self.tempfile("temp_test-card.png")	1✔
69	im.save(outfile)	1✔
70	self.assert_image_similar(im, test_card, 1.0e-3)	1✔
71
72	def test_lossy_tiled(self):	1✔
73	with Image.open("Tests/images/test-card-lossy-tiled.jp2") as im:	1✔
74	im.load()	1✔
75	self.assert_image_similar(im, test_card, 2.0)	1✔
76
77	def test_lossless_rt(self):	1✔
78	im = self.roundtrip(test_card)	1✔
79	self.assert_image_equal(im, test_card)	1✔
80
81	def test_lossy_rt(self):	1✔
82	im = self.roundtrip(test_card, quality_layers=[20])	1✔
83	self.assert_image_similar(im, test_card, 2.0)	1✔
84
85	def test_tiled_rt(self):	1✔
86	im = self.roundtrip(test_card, tile_size=(128, 128))	1✔
87	self.assert_image_equal(im, test_card)	1✔
88
89	def test_tiled_offset_rt(self):	1✔
90	im = self.roundtrip(	1✔
91	test_card, tile_size=(128, 128), tile_offset=(0, 0), offset=(32, 32)
92	)
93	self.assert_image_equal(im, test_card)	1✔
94
95	def test_tiled_offset_too_small(self):	1✔
96	with self.assertRaises(ValueError):	1✔
97	self.roundtrip(	1✔
98	test_card, tile_size=(128, 128), tile_offset=(0, 0), offset=(128, 32)
99	)
100
101	def test_irreversible_rt(self):	1✔
102	im = self.roundtrip(test_card, irreversible=True, quality_layers=[20])	1✔
103	self.assert_image_similar(im, test_card, 2.0)	1✔
104
105	def test_prog_qual_rt(self):	1✔
106	im = self.roundtrip(test_card, quality_layers=[60, 40, 20], progression="LRCP")	1✔
107	self.assert_image_similar(im, test_card, 2.0)	1✔
108
109	def test_prog_res_rt(self):	1✔
110	im = self.roundtrip(test_card, num_resolutions=8, progression="RLCP")	1✔
111	self.assert_image_equal(im, test_card)	1✔
112
113	def test_reduce(self):	1✔
114	with Image.open("Tests/images/test-card-lossless.jp2") as im:	1✔
115	im.reduce = 2	1✔
116	im.load()	1✔
117	self.assertEqual(im.size, (160, 120))	1✔
118
119	def test_layers_type(self):	1✔
120	outfile = self.tempfile("temp_layers.jp2")	1✔
121	for quality_layers in [[100, 50, 10], (100, 50, 10), None]:	1✔
122	test_card.save(outfile, quality_layers=quality_layers)	1✔
123
124	for quality_layers in ["quality_layers", ("100", "50", "10")]:	1✔
125	self.assertRaises(	1✔
126	ValueError, test_card.save, outfile, quality_layers=quality_layers
127	)
128
129	def test_layers(self):	1✔
130	out = BytesIO()	1✔
131	test_card.save(	1✔
132	out, "JPEG2000", quality_layers=[100, 50, 10], progression="LRCP"
133	)
134	out.seek(0)	1✔
135
136	with Image.open(out) as im:	1✔
137	im.layers = 1	1✔
138	im.load()	1✔
139	self.assert_image_similar(im, test_card, 13)	1✔
140
141	out.seek(0)	1✔
142	with Image.open(out) as im:	1✔
143	im.layers = 3	1✔
144	im.load()	1✔
145	self.assert_image_similar(im, test_card, 0.4)	1✔
146
147	def test_rgba(self):	1✔
148	# Arrange
149	with Image.open("Tests/images/rgb_trns_ycbc.j2k") as j2k:	1✔
150	with Image.open("Tests/images/rgb_trns_ycbc.jp2") as jp2:	1✔
151
152	# Act
153	j2k.load()	1✔
154	jp2.load()	1✔
155
156	# Assert
157	self.assertEqual(j2k.mode, "RGBA")	1✔
158	self.assertEqual(jp2.mode, "RGBA")	1✔
159
160	def test_16bit_monochrome_has_correct_mode(self):	1✔
161	with Image.open("Tests/images/16bit.cropped.j2k") as j2k:	1✔
162	j2k.load()	1✔
163	self.assertEqual(j2k.mode, "I;16")	1✔
164
165	with Image.open("Tests/images/16bit.cropped.jp2") as jp2:	1✔
166	jp2.load()	1✔
167	self.assertEqual(jp2.mode, "I;16")	1✔
168
169	@pytest.mark.xfail(is_big_endian() and on_ci(), reason="Fails on big-endian")	1✔
170	def test_16bit_monochrome_jp2_like_tiff(self):	1✔
171	with Image.open("Tests/images/16bit.cropped.tif") as tiff_16bit:	1✔
172	with Image.open("Tests/images/16bit.cropped.jp2") as jp2:	1✔
173	self.assert_image_similar(jp2, tiff_16bit, 1e-3)	1✔
174
175	@pytest.mark.xfail(is_big_endian() and on_ci(), reason="Fails on big-endian")	1✔
176	def test_16bit_monochrome_j2k_like_tiff(self):	1✔
177	with Image.open("Tests/images/16bit.cropped.tif") as tiff_16bit:	1✔
178	with Image.open("Tests/images/16bit.cropped.j2k") as j2k:	1✔
179	self.assert_image_similar(j2k, tiff_16bit, 1e-3)	1✔
180
181	def test_16bit_j2k_roundtrips(self):	1✔
182	with Image.open("Tests/images/16bit.cropped.j2k") as j2k:	1✔
183	im = self.roundtrip(j2k)	1✔
184	self.assert_image_equal(im, j2k)	1✔
185
186	def test_16bit_jp2_roundtrips(self):	1✔
187	with Image.open("Tests/images/16bit.cropped.jp2") as jp2:	1✔
188	im = self.roundtrip(jp2)	1✔
189	self.assert_image_equal(im, jp2)	1✔
190
191	def test_unbound_local(self):	1✔
192	# prepatch, a malformed jp2 file could cause an UnboundLocalError
193	# exception.
194	with self.assertRaises(IOError):	1✔
195	Image.open("Tests/images/unbound_variable.jp2")	1✔
196
197	def test_parser_feed(self):	1✔
198	# Arrange
199	from PIL import ImageFile	1✔
200
201	with open("Tests/images/test-card-lossless.jp2", "rb") as f:	1✔
202	data = f.read()	1✔
203
204	# Act
205	p = ImageFile.Parser()	1✔
206	p.feed(data)	1✔
207
208	# Assert
209	self.assertEqual(p.image.size, (640, 480))	1✔

hugovk / Pillow / #2723

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous