jyapayne/glymur
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Warnings tested with warnings.catch_warnings infrastructure.

Browse source 
Until there's some explanation as to why assertWarns method is failing,
this seems to be the only way forward.
This commit is contained in:
John Evans 2014-05-10 15:29:36 -04:00
commit 937d8c971c
11 changed files with 723 additions and 715 deletions
Download patch file Download diff file Expand all files Collapse all files

56
glymur/test/test_codestream.py
View file

@ -54,46 +54,39 @@ class TestCodestreamOpjData(unittest.TestCase):
def test_bad_rsiz(self):
"""Should warn if RSIZ is bad. Issue196"""
filename = opj_data_file('input/nonregression/edf_c2_1002767.jp2')
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
j = Jp2k(filename)
else:
with self.assertWarns(UserWarning):
j = Jp2k(filename)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
j = Jp2k(filename)
self.assertEqual(len(w), 3)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Invalid profile' in str(w[0].message))
def test_bad_wavelet_transform(self):
"""Should warn if wavelet transform is bad. Issue195"""
filename = opj_data_file('input/nonregression/edf_c2_10025.jp2')
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
j = Jp2k(filename)
else:
with self.assertWarns(UserWarning):
j = Jp2k(filename)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
j = Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Invalid wavelet transform' in str(w[0].message))
def test_invalid_progression_order(self):
"""Should still be able to parse even if prog order is invalid."""
jfile = opj_data_file('input/nonregression/2977.pdf.asan.67.2198.jp2')
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
Jp2k(jfile)
else:
with self.assertWarns(UserWarning):
Jp2k(jfile)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
Jp2k(jfile)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Invalid progression order' in str(w[0].message))
def test_tile_height_is_zero(self):
"""Zero tile height should not cause an exception."""
filename = opj_data_file('input/nonregression/2539.pdf.SIGFPE.706.1712.jp2')
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
Jp2k(filename)
else:
with self.assertWarns(UserWarning):
Jp2k(filename)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Invalid tile dimensions' in str(w[0].message))
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
@ -127,8 +120,6 @@ class TestCodestreamOpjData(unittest.TestCase):
self.assertEqual(codestream.segment[2].length, 3)
self.assertEqual(codestream.segment[2].data, b'\x00')
@unittest.skipIf(sys.hexversion < 0x03020000,
"Uses features introduced in 3.2.")
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
def test_unknown_marker_segment(self):
"""Should warn for an unknown marker."""
@ -151,8 +142,11 @@ class TestCodestreamOpjData(unittest.TestCase):
tfile.write(read_buffer)
tfile.flush()
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
codestream = Jp2k(tfile.name).get_codestream()
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Unrecognized marker' in str(w[0].message))
self.assertEqual(codestream.segment[2].marker_id, '0xff79')
self.assertEqual(codestream.segment[2].length, 3)

6
glymur/test/test_config.py
View file

@ -16,6 +16,7 @@ import os
import sys
import tempfile
import unittest
import warnings
if sys.hexversion <= 0x03030000:
from mock import patch
@ -83,8 +84,11 @@ class TestSuite(unittest.TestCase):
with patch.dict('os.environ', {'XDG_CONFIG_HOME': tdir}):
# Misconfigured new configuration file should
# be rejected.
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
imp.reload(glymur.lib.openjp2)
self.assertTrue(issubclass(w[0].category,UserWarning))
self.assertTrue('could not be loaded' in str(w[0].message))
@unittest.skipIf(glymur.lib.openjp2.OPENJP2 is None and

7
glymur/test/test_icc.py
View file

@ -62,16 +62,17 @@ class TestICC(unittest.TestCase):
self.assertEqual(profile['Creator'], 'JPEG')
@unittest.skipIf(sys.hexversion < 0x03020000,
"Uses features introduced in 3.2.")
def test_invalid_profile_header(self):
"""invalid ICC header data should cause UserWarning"""
jfile = opj_data_file('input/nonregression/orb-blue10-lin-jp2.jp2')
# assertWarns in Python 3.3 (python2.7/pylint issue)
# pylint: disable=E1101
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
Jp2k(jfile)
self.assertTrue(issubclass(w[0].category,UserWarning))
self.assertTrue('ICC profile header is corrupt' in str(w[0].message))
if __name__ == "__main__":
unittest.main()

46
glymur/test/test_jp2box.py
View file

@ -357,7 +357,6 @@ class TestChannelDefinition(unittest.TestCase):
with self.assertRaises((IOError, OSError)):
j2k.wrap(tfile.name, boxes=boxes)
@unittest.skipIf(sys.hexversion < 0x03000000, "Needs unittest in 3.x.")
def test_bad_type(self):
"""Channel types are limited to 0, 1, 2, 65535
Should reject if not all of index, channel_type, association the
@ -365,20 +364,26 @@ class TestChannelDefinition(unittest.TestCase):
"""
channel_type = (COLOR, COLOR, 3)
association = (RED, GREEN, BLUE)
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
glymur.jp2box.ChannelDefinitionBox(channel_type=channel_type,
association=association)
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[0].category, UserWarning))
@unittest.skipIf(sys.hexversion < 0x03000000, "Needs unittest in 3.x.")
def test_wrong_lengths(self):
"""Should reject if not all of index, channel_type, association the
same length.
"""
channel_type = (COLOR, COLOR)
association = (RED, GREEN, BLUE)
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
glymur.jp2box.ChannelDefinitionBox(channel_type=channel_type,
association=association)
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[0].category, UserWarning))
class TestFileTypeBox(unittest.TestCase):
@ -474,32 +479,41 @@ class TestColourSpecificationBox(unittest.TestCase):
self.assertEqual(colr.colorspace, glymur.core.SRGB)
self.assertIsNone(colr.icc_profile)
@unittest.skipIf(sys.hexversion < 0x03030000, "Requires 3.3+")
def test_colr_with_cspace_and_icc(self):
"""Colour specification boxes can't have both."""
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
colorspace = glymur.core.SRGB
rawb = b'\x01\x02\x03\x04'
glymur.jp2box.ColourSpecificationBox(colorspace=colorspace,
icc_profile=rawb)
self.assertTrue(issubclass(w[0].category,UserWarning))
msg = 'Colorspace and icc_profile cannot both be set'
self.assertTrue(msg in str(w[0].message))
@unittest.skipIf(sys.hexversion < 0x03030000, "Requires 3.3+")
def test_colr_with_bad_method(self):
"""colr must have a valid method field"""
colorspace = glymur.core.SRGB
method = -1
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
glymur.jp2box.ColourSpecificationBox(colorspace=colorspace,
method=method)
self.assertTrue(issubclass(w[0].category,UserWarning))
msg = 'Invalid method'
self.assertTrue(msg in str(w[0].message))
@unittest.skipIf(sys.hexversion < 0x03030000, "Requires 3.3+")
def test_colr_with_bad_approx(self):
"""colr should have a valid approximation field"""
colorspace = glymur.core.SRGB
approx = -1
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
glymur.jp2box.ColourSpecificationBox(colorspace=colorspace,
approximation=approx)
self.assertTrue(issubclass(w[0].category,UserWarning))
msg = 'Invalid approximation'
self.assertTrue(msg in str(w[0].message))
def test_colr_with_bad_color(self):
"""colr must have a valid color, strange as though that may sound."""
@ -523,25 +537,29 @@ class TestPaletteBox(unittest.TestCase):
def tearDown(self):
pass
@unittest.skipIf(sys.hexversion < 0x03000000, "Needs unittest in 3.x.")
def test_mismatched_bitdepth_signed(self):
"""bitdepth and signed arguments must have equal length"""
palette = np.array([[255, 0, 255], [0, 255, 0]], dtype=np.uint8)
bps = (8, 8, 8)
signed = (False, False)
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
pclr = glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed)
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[0].category, UserWarning))
@unittest.skipIf(sys.hexversion < 0x03000000, "Needs unittest in 3.x.")
def test_mismatched_signed_palette(self):
"""bitdepth and signed arguments must have equal length"""
palette = np.array([[255, 0, 255], [0, 255, 0]], dtype=np.uint8)
bps = (8, 8, 8, 8)
signed = (False, False, False, False)
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
pclr = glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed)
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[0].category, UserWarning))
def test_writing_with_different_bitdepths(self):
"""Bitdepths must be the same when writing."""

35
glymur/test/test_jp2box_jpx.py
View file

@ -305,15 +305,17 @@ class TestJPXWrap(unittest.TestCase):
with self.assertRaises(IOError):
jp2.wrap(tfile.name, boxes=boxes)
@unittest.skipIf(sys.hexversion < 0x03000000, "Needs unittest in 3.x.")
def test_deurl_child_of_dtbl(self):
"""Data reference boxes can only contain data entry url boxes."""
jp2 = Jp2k(self.jp2file)
boxes = [jp2.box[idx] for idx in [0, 1, 2, 4]]
ftyp = glymur.jp2box.FileTypeBox()
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
dref = glymur.jp2box.DataReferenceBox([ftyp])
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[0].category, UserWarning))
# Try to get around it by appending the ftyp box after creation.
dref = glymur.jp2box.DataReferenceBox()
@ -484,35 +486,6 @@ class TestJPX(unittest.TestCase):
with tempfile.TemporaryFile() as tfile:
ftbl.write(tfile)
@unittest.skip("No such jpx file anymore.")
def test_jpx_rreq_mask_length_3(self):
"""There are some JPX files with rreq mask length of 3."""
jpx = Jp2k(self.jpxfile)
self.assertEqual(jpx.box[2].box_id, 'rreq')
self.assertEqual(type(jpx.box[2]),
glymur.jp2box.ReaderRequirementsBox)
self.asserwrite_buffertEqual(jpx.box[2].standard_flag,
(5, 42, 45, 2, 18, 19, 1, 8, 12, 31, 20))
@unittest.skip("Requires unnecessarily complicated code")
def test_unknown_superbox(self):
"""Verify that we can handle an unknown superbox."""
with tempfile.NamedTemporaryFile(suffix='.jpx') as tfile:
with open(self.jpxfile, 'rb') as ifile:
tfile.write(ifile.read())
# Add the header for an unknwon superbox.
write_buffer = struct.pack('>I4s', 20, 'grp '.encode())
tfile.write(write_buffer)
write_buffer = struct.pack('>I4sI', 12, 'free'.encode(), 0)
tfile.write(write_buffer)
tfile.flush()
with self.assertWarns(UserWarning):
jpx = Jp2k(tfile.name)
self.assertEqual(jpx.box[-1].box_id, b'grp ')
self.assertEqual(jpx.box[-1].box[0].box_id, 'free')
def test_data_reference_requires_dtbl(self):
"""The existance of a data reference box requires a ftbl box as well."""
flag = 0

17
glymur/test/test_jp2box_uuid.py
View file

@ -83,7 +83,6 @@ class TestUUIDExif(unittest.TestCase):
def tearDown(self):
pass
@unittest.skipIf(sys.hexversion < 0x03000000, "Requires assertWarns, 3.2+")
def test_unrecognized_exif_tag(self):
"""Verify warning in case of unrecognized tag."""
with tempfile.NamedTemporaryFile(suffix='.jp2', mode='wb') as tfile:
@ -106,10 +105,13 @@ class TestUUIDExif(unittest.TestCase):
tfile.write(struct.pack('<HHI4s', 171, 2, 3, b'HTC\x00'))
tfile.flush()
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
j = glymur.Jp2k(tfile.name)
self.assertTrue(issubclass(w[0].category, UserWarning))
msg = 'Unrecognized Exif tag'
self.assertTrue(msg in str(w[0].message))
@unittest.skipIf(sys.hexversion < 0x03000000, "Requires assertWarns, 3.2+")
def test_bad_tag_datatype(self):
"""Only certain datatypes are allowable"""
with tempfile.NamedTemporaryFile(suffix='.jp2', mode='wb') as tfile:
@ -132,12 +134,13 @@ class TestUUIDExif(unittest.TestCase):
tfile.write(struct.pack('<HHI4s', 271, 2000, 3, b'HTC\x00'))
tfile.flush()
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
j = glymur.Jp2k(tfile.name)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertEqual(j.box[-1].box_id, 'uuid')
@unittest.skipIf(sys.hexversion < 0x03000000, "Requires assertWarns, 3.2+")
def test_bad_tiff_header_byte_order_indication(self):
"""Only b'II' and b'MM' are allowed."""
with tempfile.NamedTemporaryFile(suffix='.jp2', mode='wb') as tfile:
@ -160,8 +163,10 @@ class TestUUIDExif(unittest.TestCase):
tfile.write(struct.pack('<HHI4s', 271, 2, 3, b'HTC\x00'))
tfile.flush()
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
j = glymur.Jp2k(tfile.name)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertEqual(j.box[-1].box_id, 'uuid')

38
glymur/test/test_jp2box_xml.py
View file

@ -207,12 +207,9 @@ class TestJp2kBadXmlFile(unittest.TestCase):
def tearDown(self):
pass
@unittest.skipIf(sys.hexversion < 0x03020000,
"Uses features introduced in 3.2.")
def test_invalid_xml_box_warning(self):
"""Should warn in case of bad XML"""
with self.assertWarns(UserWarning):
Jp2k(self._bad_xml_file)
Jp2k(self._bad_xml_file)
def test_invalid_xml_box(self):
"""Should be able to recover info from xml box with bad xml."""
@ -267,12 +264,14 @@ class TestBadButRecoverableXmlFile(unittest.TestCase):
def tearDownClass(cls):
os.unlink(cls._bad_xml_file)
@unittest.skipIf(sys.hexversion < 0x03020000,
"Uses features introduced in 3.2.")
def test_bad_xml_box_warning(self):
"""Should warn in case of bad XML"""
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
Jp2k(self._bad_xml_file)
self.assertTrue(issubclass(w[0].category, UserWarning))
msg = 'A UnicodeDecodeError was encountered parsing an XML box'
self.assertTrue(msg in str(w[0].message))
def test_recover_from_bad_xml(self):
"""Should be able to recover info from xml box with bad xml."""
@ -297,13 +296,13 @@ class TestXML_OpjDataRoot(unittest.TestCase):
filename = opj_data_file(os.path.join('input',
'nonregression',
'issue171.jp2'))
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
jp2 = Jp2k(filename)
else:
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
msg = 'An illegal BOM (byte order marker) was detected and removed'
self.assertTrue(msg in str(w[0].message))
self.assertIsNotNone(jp2.box[3].xml)
@ -312,13 +311,10 @@ class TestXML_OpjDataRoot(unittest.TestCase):
filename = opj_data_file(os.path.join('input',
'nonregression',
'26ccf3651020967f7778238ef5af08af.SIGFPE.d25.527.jp2'))
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
jp2 = Jp2k(filename)
else:
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertIsNone(jp2.box[3].box[1].box[1].xml)

68
glymur/test/test_jp2k.py
View file

@ -757,8 +757,9 @@ class TestJp2k_2_1(unittest.TestCase):
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
class TestParsing(unittest.TestCase):
"""Tests for verifying how paring may be altered."""
"""Tests for verifying how parsing may be altered."""
def setUp(self):
self.jp2file = glymur.data.nemo()
# Reset parseoptions for every test.
glymur.set_parseoptions(codestream=True)
@ -775,11 +776,11 @@ class TestParsing(unittest.TestCase):
self.assertEqual(len(w), 0)
glymur.set_parseoptions(codestream=True)
if sys.hexversion >= 0x03000000:
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
with warnings.catch_warnings(record=True) as w:
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Invalid profile' in str(w[0].message))
@unittest.skip("blah")
def test_main_header(self):
"""Verify that the main header is not loaded when parsing turned off."""
# The hidden _main_header attribute should show up after accessing it.
@ -792,44 +793,62 @@ class TestParsing(unittest.TestCase):
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
class TestJp2kOpjDataRoot(unittest.TestCase):
class TestJp2kOpjDataRootWarnings(unittest.TestCase):
"""These tests should be run by just about all configuration."""
def test_undecodeable_box_id(self):
"""Should warn in case of undecodeable box ID but not error out."""
filename = opj_data_file('input/nonregression/edf_c2_1013627.jp2')
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
jp2 = Jp2k(filename)
else:
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Unrecognized box' in str(w[0].message))
# Now make sure we got all of the boxes. Ignore the last, which was
# bad.
box_ids = [box.box_id for box in jp2.box[:-1]]
self.assertEqual(box_ids, ['jP ', 'ftyp', 'jp2h', 'jp2c'])
def test_invalid_approximation(self):
def test_bad_ftyp_brand(self):
"""Should warn in case of bad ftyp brand."""
filename = opj_data_file('input/nonregression/edf_c2_1000290.jp2')
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
@unittest.skipIf(sys.hexversion < 0x03000000, "Test requires Python 3.3+")
def test_invalid_approximation(self):
"""Should warn in case of invalid approximation."""
filename = opj_data_file('input/nonregression/edf_c2_1015644.jp2')
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[0].category, UserWarning))
self.assertTrue('Invalid approximation' in str(w[0].message))
@unittest.skipIf(sys.hexversion < 0x03000000, "Test requires Python 3.3+")
def test_invalid_colorspace(self):
"""Should warn in case of invalid colorspace."""
filename = opj_data_file('input/nonregression/edf_c2_1103421.jp2')
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[1].category, UserWarning))
self.assertTrue('Unrecognized colorspace' in str(w[1].message))
def test_stupid_windows_eol_at_end(self):
"""Garbage characters at the end of the file."""
filename = opj_data_file('input/nonregression/issue211.jp2')
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
jp2 = Jp2k(filename)
self.assertTrue(issubclass(w[1].category, UserWarning))
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
class TestJp2kOpjDataRoot(unittest.TestCase):
"""These tests should be run by just about all configuration."""
def test_no_cxform_pclr_jp2(self):
"""Indices for pclr jpxfile if no color transform"""
@ -849,17 +868,6 @@ class TestJp2kOpjDataRoot(unittest.TestCase):
rgb_from_idx[r, c] = palette[idx[r, c]]
np.testing.assert_array_equal(rgb, rgb_from_idx)
def test_stupid_windows_eol_at_end(self):
"""Garbage characters at the end of the file."""
filename = opj_data_file('input/nonregression/issue211.jp2')
if sys.hexversion < 0x03000000:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
jp2 = Jp2k(filename)
else:
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
def test_read_differing_subsamples(self):
"""should error out with read used on differently subsampled images"""
# Verify that we error out appropriately if we use the read method

1140
glymur/test/test_opj_suite.py
View file

File diff suppressed because it is too large Load diff

11
glymur/test/test_opj_suite_neg.py
View file

@ -13,6 +13,7 @@ import re
import sys
import tempfile
import unittest
import warnings
import numpy as np
@ -77,14 +78,13 @@ class TestSuiteNegative(unittest.TestCase):
jp2k.get_codestream(header_only=False)
self.assertTrue(True)
@unittest.skipIf(sys.hexversion < 0x03020000,
"Uses features introduced in 3.2.")
def test_nr_illegalclrtransform(self):
"""EOC marker is bad"""
relpath = 'input/nonregression/illegalcolortransform.j2k'
jfile = opj_data_file(relpath)
jp2k = Jp2k(jfile)
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('ignore')
codestream = jp2k.get_codestream(header_only=False)
# Verify that the last segment returned in the codestream is SOD,
@ -119,8 +119,6 @@ class TestSuiteNegative(unittest.TestCase):
with self.assertRaises(IOError):
j.write(data, cbsize=(2, 2048))
@unittest.skipIf(sys.hexversion < 0x03020000,
"Uses features introduced in 3.2.")
def test_exceeded_box(self):
"""should warn if reading past end of a box"""
# Verify that a warning is issued if we read past the end of a box
@ -128,7 +126,8 @@ class TestSuiteNegative(unittest.TestCase):
# short.
infile = os.path.join(OPJ_DATA_ROOT,
'input/nonregression/mem-b2ace68c-1381.jp2')
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('ignore')
Jp2k(infile)
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.")

14
glymur/test/test_printing.py
View file

@ -70,7 +70,6 @@ class TestPrinting(unittest.TestCase):
self.assertTrue(True)
@unittest.skipIf(sys.hexversion < 0x03000000, "Needs unittest in 3.x.")
def test_unknown_superbox(self):
"""Verify that we can handle an unknown superbox."""
with tempfile.NamedTemporaryFile(suffix='.jpx') as tfile:
@ -87,14 +86,19 @@ class TestPrinting(unittest.TestCase):
tfile.write(write_buffer)
tfile.flush()
with self.assertWarns(UserWarning):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
jpx = Jp2k(tfile.name)
self.assertTrue(len(w), 1)
glymur.set_printoptions(short=True)
with patch('sys.stdout', new=StringIO()) as fake_out:
print(jpx.box[-1])
actual = fake_out.getvalue().strip()
lines = ["Unknown Box (b'grp ') @ (1399071, 20)"]
expected = '\n'.join(lines)
if sys.hexversion < 0x03000000:
expected = "Unknown Box (grp ) @ (1399071, 20)"
else:
expected = "Unknown Box (b'grp ') @ (1399071, 20)"
self.assertEqual(actual, expected)
def test_printoptions_bad_argument(self):
@ -767,7 +771,7 @@ class TestPrintingOpjDataRoot(unittest.TestCase):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
jp2 = Jp2k(jfile)
codestream = jp2.get_codestream()
codestream = jp2.get_codestream()
with patch('sys.stdout', new=StringIO()) as fake_out:
print(codestream.segment[2])
actual = fake_out.getvalue().strip()