diff --git a/glymur/test/test_jp2k.py b/glymur/test/test_jp2k.py index 1371a05..8b04dfa 100644 --- a/glymur/test/test_jp2k.py +++ b/glymur/test/test_jp2k.py @@ -1,4 +1,15 @@ -# pylint: disable-all +""" +Tests for general glymur functionality. +""" +# E1101: assertWarns introduced in python 3.2 +# pylint: disable=E1101 + +# R0904: Not too many methods in unittest. +# pylint: disable=R0904 + +# E0611: unittest.mock is unknown to python2.7/pylint +# pylint: disable=E0611,F0401 + import doctest import os import re @@ -25,20 +36,24 @@ import pkg_resources import glymur from glymur import Jp2k -from glymur.lib import openjp2 as opj2 from .fixtures import OPENJP2_IS_V2_OFFICIAL try: - data_root = os.environ['OPJ_DATA_ROOT'] + DATA_ROOT = os.environ['OPJ_DATA_ROOT'] except KeyError: - data_root = None + DATA_ROOT = None except: raise # Doc tests should be run as well. def load_tests(loader, tests, ignore): + # W0613: "loader" and "ignore" are necessary for the protocol + # They are unused here, however. + # pylint: disable=W0613 + + """Should run doc tests as well""" if os.name == "nt": # Can't do it on windows, temporary file issue. return tests @@ -54,6 +69,7 @@ def load_tests(loader, tests, ignore): glymur.lib.openjpeg.OPENJPEG is None, "Missing openjp2 library.") class TestConfig(unittest.TestCase): + """Test suite for reading without proper library in place.""" def setUp(self): self.jp2file = glymur.data.nemo() @@ -62,24 +78,24 @@ class TestConfig(unittest.TestCase): def tearDown(self): pass - def test_read_without_library_backing_us_up(self): + def test_read_without_library(self): """Don't have either openjp2 or openjpeg libraries? Must error out. """ with patch('glymur.lib.openjp2.OPENJP2', new=None): with patch('glymur.lib.openjpeg.OPENJPEG', new=None): with self.assertRaises(glymur.jp2k.LibraryNotFoundError): - d = glymur.Jp2k(self.jp2file).read() + glymur.Jp2k(self.jp2file).read() - def test_read_bands_without_library_backing_us_up(self): + def test_read_bands_without_library(self): """Don't have openjp2 library? Must error out. """ with patch('glymur.lib.openjp2.OPENJP2', new=None): with patch('glymur.lib.openjpeg.OPENJPEG', new=None): with self.assertRaises(glymur.jp2k.LibraryNotFoundError): - d = glymur.Jp2k(self.jp2file).read_bands() + glymur.Jp2k(self.jp2file).read_bands() @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_write_without_library_backing_us_up(self): + def test_write_without_library(self): """Don't have openjp2 library? Must error out. """ data = glymur.Jp2k(self.j2kfile).read() @@ -95,32 +111,34 @@ class TestConfig(unittest.TestCase): @unittest.skipIf(glymur.lib.openjp2.OPENJP2 is None, "Missing openjp2 library.") class TestJp2kBadXmlFile(unittest.TestCase): + """Test suite for bad XML box situations""" @classmethod def setUpClass(cls): - # Setup a JP2 file with a bad XML box. We only need to do this once - # per class rather than once per test. + """Setup a JP2 file with a bad XML box. We only need to do this once + per class rather than once per test. + """ jp2file = pkg_resources.resource_filename(glymur.__name__, "data/nemo.jp2") with tempfile.NamedTemporaryFile(suffix='.jp2', delete=False) as tfile: cls._bad_xml_file = tfile.name with open(jp2file, 'rb') as ifile: # Everything up until the jp2c box. - buffer = ifile.read(77) - tfile.write(buffer) + write_buffer = ifile.read(77) + tfile.write(write_buffer) # Write the xml box with bad xml # Length = 28, id is 'xml '. - buffer = struct.pack('>I4s', int(28), b'xml ') - tfile.write(buffer) + write_buffer = struct.pack('>I4s', int(28), b'xml ') + tfile.write(write_buffer) - buffer = 'this is a test' - buffer = buffer.encode() - tfile.write(buffer) + write_buffer = 'this is a test' + write_buffer = write_buffer.encode() + tfile.write(write_buffer) # Get the rest of the input file. - buffer = ifile.read() - tfile.write(buffer) + write_buffer = ifile.read() + tfile.write(write_buffer) tfile.flush() @classmethod @@ -137,13 +155,12 @@ class TestJp2kBadXmlFile(unittest.TestCase): @unittest.skipIf(sys.hexversion < 0x03020000, "Uses features introduced in 3.2.") def test_invalid_xml_box_warning(self): - # Should be able to recover from xml box with bad xml. - # Just verify that a warning is issued on 3.3+ - with self.assertWarns(UserWarning) as cw: - jp2k = Jp2k(self._bad_xml_file) + """Should warn in case of bad XML""" + with self.assertWarns(UserWarning): + Jp2k(self._bad_xml_file) def test_invalid_xml_box(self): - # Should be able to recover from xml box with bad xml. + """Should be able to recover info from xml box with bad xml.""" with warnings.catch_warnings(): warnings.simplefilter("ignore") jp2k = Jp2k(self._bad_xml_file) @@ -157,6 +174,7 @@ class TestJp2kBadXmlFile(unittest.TestCase): @unittest.skipIf(glymur.lib.openjp2.OPENJP2 is None, "Missing openjp2 library.") class TestJp2k(unittest.TestCase): + """Test suite for version 2.0/2.0+ of openjpeg""" def setUp(self): self.jp2file = glymur.data.nemo() @@ -166,7 +184,7 @@ class TestJp2k(unittest.TestCase): pass def test_rlevel_max(self): - # Verify that rlevel=-1 gets us the lowest resolution image + """Verify that rlevel=-1 gets us the lowest resolution image""" j = Jp2k(self.j2kfile) thumbnail1 = j.read(rlevel=-1) thumbnail2 = j.read(rlevel=5) @@ -174,43 +192,41 @@ class TestJp2k(unittest.TestCase): self.assertEqual(thumbnail1.shape, (25, 15, 3)) def test_bad_area_parameter(self): - # Verify that we error out appropriately if given a bad area parameter. + """Should error out appropriately if given a bad area parameter.""" j = Jp2k(self.jp2file) with self.assertRaises(IOError): # Start corner must be >= 0 - d = j.read(area=(-1, -1, 1, 1)) + j.read(area=(-1, -1, 1, 1)) with self.assertRaises(IOError): # End corner must be > 0 - d = j.read(area=(10, 10, 0, 0)) + j.read(area=(10, 10, 0, 0)) with self.assertRaises(IOError): # End corner must be >= start corner - d = j.read(area=(10, 10, 8, 8)) + j.read(area=(10, 10, 8, 8)) def test_rlevel_too_high(self): - # Verify that we error out appropriately if not given a JPEG 2000 file. + """Should error out appropriately if reduce level too high""" j = Jp2k(self.jp2file) with self.assertRaises(IOError): - d = j.read(rlevel=6) + j.read(rlevel=6) - def test_not_JPEG2000(self): - # Verify that we error out appropriately if not given a JPEG 2000 file. + def test_not_jpeg2000(self): + """Should error out appropriately if not given a JPEG 2000 file.""" filename = pkg_resources.resource_filename(glymur.__name__, "jp2k.py") with self.assertRaises(IOError): - jp2k = Jp2k(filename) + Jp2k(filename) def test_file_not_present(self): + """Should error out if reading from a file that does not exist""" # Verify that we error out appropriately if not given an existing file # at all. - if sys.hexversion < 0x03030000: - error = OSError - else: - error = IOError - with self.assertRaises(error): + with self.assertRaises(OSError): filename = 'this file does not actually exist on the file system.' - jp2k = Jp2k(filename) + Jp2k(filename) @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_write_srgb_without_mct(self): + """should be able to write RGB without specifying mct""" j2k = Jp2k(self.j2kfile) expdata = j2k.read() with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: @@ -219,12 +235,12 @@ class TestJp2k(unittest.TestCase): actdata = ofile.read() np.testing.assert_array_equal(actdata, expdata) - c = ofile.get_codestream() - self.assertEqual(c.segment[2].spcod[3], 0) # no mct + codestream = ofile.get_codestream() + self.assertEqual(codestream.segment[2].spcod[3], 0) # no mct @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_write_grayscale_with_mct(self): - # MCT usage makes no sense for grayscale images. + """MCT usage makes no sense for grayscale images.""" j2k = Jp2k(self.j2kfile) expdata = j2k.read() with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: @@ -234,6 +250,7 @@ class TestJp2k(unittest.TestCase): @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_write_cprl(self): + """Must be able to write a CPRL progression order file""" # Issue 17 j = Jp2k(self.jp2file) expdata = j.read(rlevel=1) @@ -243,11 +260,11 @@ class TestJp2k(unittest.TestCase): actdata = ofile.read() np.testing.assert_array_equal(actdata, expdata) - c = ofile.get_codestream() - self.assertEqual(c.segment[2].spcod[0], glymur.core.CPRL) + codestream = ofile.get_codestream() + self.assertEqual(codestream.segment[2].spcod[0], glymur.core.CPRL) def test_jp2_boxes(self): - # Verify the boxes of a JP2 file. + """Verify the boxes of a JP2 file. Basic jp2 test.""" jp2k = Jp2k(self.jp2file) # top-level boxes @@ -305,39 +322,41 @@ class TestJp2k(unittest.TestCase): self.assertEqual(jp2k.box[2].box[1].colorspace, glymur.core.SRGB) self.assertIsNone(jp2k.box[2].box[1].icc_profile) - @unittest.skipIf(data_root is None, + @unittest.skipIf(DATA_ROOT is None, "OPJ_DATA_ROOT environment variable not set") def test_j2k_box(self): + """A J2K/J2C file must not have any boxes.""" # Verify that a J2K file has no boxes. - filename = os.path.join(data_root, 'input/conformance/p0_01.j2k') + filename = os.path.join(DATA_ROOT, 'input/conformance/p0_01.j2k') jp2k = Jp2k(filename) self.assertEqual(len(jp2k.box), 0) @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_64bit_XL_field(self): + def test_64bit_xl_field(self): + """XL field should be supported""" # Verify that boxes with the XL field are properly read. # Don't have such a file on hand, so we create one. Copy our example # file, but making the codestream have a 64-bit XL field. with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with open(self.jp2file, 'rb') as ifile: # Everything up until the jp2c box. - buffer = ifile.read(3127) - tfile.write(buffer) + write_buffer = ifile.read(3127) + tfile.write(write_buffer) # The L field must be 1 in order to signal the presence of the # XL field. The actual length of the jp2c box increased by 8 # (8 bytes for the XL field). - L = 1 - T = b'jp2c' - XL = 1133427 + 8 - buffer = struct.pack('>I4sQ', int(L), T, XL) - tfile.write(buffer) + length = 1 + typ = b'jp2c' + xlen = 1133427 + 8 + write_buffer = struct.pack('>I4sQ', int(length), typ, xlen) + tfile.write(write_buffer) # Get the rest of the input file (minus the 8 bytes for L and # T. ifile.seek(8, 1) - buffer = ifile.read() - tfile.write(buffer) + write_buffer = ifile.read() + tfile.write(write_buffer) tfile.flush() jp2k = Jp2k(tfile.name) @@ -347,7 +366,8 @@ class TestJp2k(unittest.TestCase): self.assertEqual(jp2k.box[5].length, 1133427 + 8) @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_L_is_zero(self): + def test_length_field_is_zero(self): + """L=0 (length field in box header) is allowed""" # Verify that boxes with the L field as zero are correctly read. # This should only happen in the last box of a JPEG 2000 file. # Our example image has its last box at byte 588458. @@ -355,19 +375,19 @@ class TestJp2k(unittest.TestCase): with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with open(self.jp2file, 'rb') as ifile: # Everything up until the jp2c box. - buffer = ifile.read(588458) - tfile.write(buffer) + write_buffer = ifile.read(588458) + tfile.write(write_buffer) - L = 0 - T = b'uuid' - buffer = struct.pack('>I4s', int(L), T) - tfile.write(buffer) + length = 0 + typ = b'uuid' + write_buffer = struct.pack('>I4s', int(length), typ) + tfile.write(write_buffer) # Get the rest of the input file (minus the 8 bytes for L and # T. ifile.seek(8, 1) - buffer = ifile.read() - tfile.write(buffer) + write_buffer = ifile.read() + tfile.write(write_buffer) tfile.flush() new_jp2 = Jp2k(tfile.name) @@ -381,31 +401,34 @@ class TestJp2k(unittest.TestCase): self.assertEqual(new_jp2.box[j].length, baseline_jp2.box[j].length) - @unittest.skipIf(data_root is None, + @unittest.skipIf(DATA_ROOT is None, "OPJ_DATA_ROOT environment variable not set") 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 # on an image with differing subsamples # # Issue 86. - filename = os.path.join(data_root, 'input/conformance/p0_05.j2k') + filename = os.path.join(DATA_ROOT, 'input/conformance/p0_05.j2k') j = Jp2k(filename) with self.assertRaises(RuntimeError): j.read() - @unittest.skipIf(data_root is None, + @unittest.skipIf(DATA_ROOT is None, "OPJ_DATA_ROOT environment variable not set") def test_empty_box_with_j2k(self): - # Verify that the list of boxes in a J2C/J2K file is present, but - # empty. - filename = os.path.join(data_root, 'input/conformance/p0_05.j2k') + """Verify that the list of boxes in a J2C/J2K file is present, but + empty. + """ + filename = os.path.join(DATA_ROOT, 'input/conformance/p0_05.j2k') j = Jp2k(filename) self.assertEqual(j.box, []) @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_code_block_height_different_than_width(self): - # Verify that we can set a code block size where height does not equal - # width. + def test_cblkh_different_than_width(self): + """Verify that we can set a code block size where height does not equal + width. + """ data = np.zeros((128, 128), dtype=np.uint8) with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: j = Jp2k(tfile.name, 'wb') @@ -413,49 +436,50 @@ class TestJp2k(unittest.TestCase): # The code block dimensions are given as rows x columns. j.write(data, cbsize=(16, 32)) - c = j.get_codestream() + codestream = j.get_codestream() # Code block size is reported as XY in the codestream. - self.assertEqual(tuple(c.segment[2].spcod[5:7]), (3, 2)) + self.assertEqual(tuple(codestream.segment[2].spcod[5:7]), (3, 2)) @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_negative_too_many_dimensions(self): - # OpenJP2 only allows 2D or 3D images. + def test_too_many_dimensions(self): + """OpenJP2 only allows 2D or 3D images.""" with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: j = Jp2k(tfile.name, 'wb') - with self.assertRaises(IOError) as ce: + with self.assertRaises(IOError): data = np.zeros((128, 128, 2, 2), dtype=np.uint8) j.write(data) @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_unrecognized_jp2_colorspace(self): - # We only allow RGB and GRAYSCALE. + def test_unrecognized_jp2_clrspace(self): + """We only allow RGB and GRAYSCALE. Should error out with others""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') - with self.assertRaises(IOError) as ce: + with self.assertRaises(IOError): data = np.zeros((128, 128, 3), dtype=np.uint8) j.write(data, colorspace='cmyk') @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_2D_rgb(self): - # RGB must have at least 3 components. + def test_2d_rgb(self): + """RGB must have at least 3 components.""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') - with self.assertRaises(IOError) as ce: + with self.assertRaises(IOError): data = np.zeros((128, 128, 2), dtype=np.uint8) j.write(data, colorspace='rgb') @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_colorspace_with_j2k(self): - # Specifying a colorspace with J2K does not make sense. + """Specifying a colorspace with J2K does not make sense""" with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: j = Jp2k(tfile.name, 'wb') - with self.assertRaises(IOError) as ce: + with self.assertRaises(IOError): data = np.zeros((128, 128, 3), dtype=np.uint8) j.write(data, colorspace='rgb') @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_specify_rgb(self): + """specify RGB explicitly""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') data = np.zeros((128, 128, 3), dtype=np.uint8) @@ -464,6 +488,7 @@ class TestJp2k(unittest.TestCase): @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_specify_gray(self): + """test gray explicitly specified (that's GRAY, not GREY)""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') data = np.zeros((128, 128), dtype=np.uint8) @@ -473,6 +498,7 @@ class TestJp2k(unittest.TestCase): @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_specify_grey(self): + """test grey explicitly specified""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') data = np.zeros((128, 128), dtype=np.uint8) @@ -484,6 +510,7 @@ class TestJp2k(unittest.TestCase): "Does not seem to work on official v2.0.0 release.") @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_grey_with_extra_component(self): + """version 2.0 cannot write gray + extra""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') data = np.zeros((128, 128, 2), dtype=np.uint8) @@ -495,7 +522,8 @@ class TestJp2k(unittest.TestCase): glymur.core.GREYSCALE) @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_grey_with_two_extra_components(self): + def test_grey_with_two_extra_comps(self): + """should be able to write gray + two extra components""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') data = np.zeros((128, 128, 3), dtype=np.uint8) @@ -510,6 +538,7 @@ class TestJp2k(unittest.TestCase): "Does not seem to work on official v2.0.0 release.") @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_rgb_with_extra_component(self): + """v2.0+ should be able to write extra components""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') data = np.zeros((128, 128, 4), dtype=np.uint8) @@ -522,7 +551,8 @@ class TestJp2k(unittest.TestCase): @unittest.skipIf(OPENJP2_IS_V2_OFFICIAL is False, "Test is specific for v2.0.0 release") @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_extra_components_on_v2_official(self): + def test_extra_components_on_v2(self): + """must error out in 1.x with extra components.""" # Extra components seems to require 2.0+. Verify that we error out. with self.assertRaises(IOError): with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: @@ -531,48 +561,50 @@ class TestJp2k(unittest.TestCase): j.write(data) def test_specify_ycc(self): - # We don't support writing YCC at the moment. + """Should reject YCC""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: j = Jp2k(tfile.name, 'wb') - with self.assertRaises(IOError) as ce: + with self.assertRaises(IOError): data = np.zeros((128, 128, 3), dtype=np.uint8) j.write(data, colorspace='ycc') @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_uinf_ulst_url_boxes(self): + """Verify that we can read UINF, ULST, and URL boxes""" # Verify that we can read UINF, ULST, and URL boxes. I don't have # easy access to such a file, and there's no such file in the # openjpeg repository, so I'll fake one. with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with open(self.jp2file, 'rb') as ifile: # Everything up until the jp2c box. - buffer = ifile.read(77) - tfile.write(buffer) + write_buffer = ifile.read(77) + tfile.write(write_buffer) # Write the UINF superbox # Length = 50, id is uinf. - buffer = struct.pack('>I4s', int(50), b'uinf') - tfile.write(buffer) + write_buffer = struct.pack('>I4s', int(50), b'uinf') + tfile.write(write_buffer) # Write the ULST box. # Length is 26, 1 UUID, hard code that UUID as zeros. - buffer = struct.pack('>I4sHIIII', int(26), b'ulst', int(1), - int(0), int(0), int(0), int(0)) - tfile.write(buffer) + write_buffer = struct.pack('>I4sHIIII', int(26), b'ulst', + int(1), int(0), int(0), int(0), + int(0)) + tfile.write(write_buffer) # Write the URL box. # Length is 16, version is one byte, flag is 3 bytes, url # is the rest. - buffer = struct.pack('>I4sBBBB', - int(16), b'url ', - int(0), int(0), int(0), int(0)) - tfile.write(buffer) - buffer = struct.pack('>ssss', b'a', b'b', b'c', b'd') - tfile.write(buffer) + write_buffer = struct.pack('>I4sBBBB', + int(16), b'url ', + int(0), int(0), int(0), int(0)) + tfile.write(write_buffer) + write_buffer = struct.pack('>ssss', b'a', b'b', b'c', b'd') + tfile.write(write_buffer) # Get the rest of the input file. - buffer = ifile.read() - tfile.write(buffer) + write_buffer = ifile.read() + tfile.write(write_buffer) tfile.flush() jp2k = Jp2k(tfile.name) @@ -596,27 +628,26 @@ class TestJp2k(unittest.TestCase): self.assertEqual(jp2k.box[3].box[1].url, 'abcd') @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") - def test_xml_box_with_trailing_nulls(self): - # ElementTree does not like trailing null chars after valid XML - # text. + def test_xml_with_trailing_nulls(self): + """ElementTree doesn't like trailing null chars after valid XML text""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with open(self.jp2file, 'rb') as ifile: # Everything up until the jp2c box. - buffer = ifile.read(77) - tfile.write(buffer) + write_buffer = ifile.read(77) + tfile.write(write_buffer) # Write the xml box # Length = 36, id is 'xml '. - buffer = struct.pack('>I4s', int(36), b'xml ') - tfile.write(buffer) + write_buffer = struct.pack('>I4s', int(36), b'xml ') + tfile.write(write_buffer) - buffer = 'this is a test' + chr(0) - buffer = buffer.encode() - tfile.write(buffer) + write_buffer = 'this is a test' + chr(0) + write_buffer = write_buffer.encode() + tfile.write(write_buffer) # Get the rest of the input file. - buffer = ifile.read() - tfile.write(buffer) + write_buffer = ifile.read() + tfile.write(write_buffer) tfile.flush() jp2k = Jp2k(tfile.name) @@ -629,6 +660,7 @@ class TestJp2k(unittest.TestCase): @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_asoc_label_box(self): + """Test asoc and label box""" # Construct a fake file with an asoc and a label box, as # OpenJPEG doesn't have such a file. data = Jp2k(self.jp2file).read(rlevel=1) @@ -639,30 +671,30 @@ class TestJp2k(unittest.TestCase): with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile2: # Offset of the codestream is where we start. - buffer = tfile.read(77) - tfile2.write(buffer) + read_buffer = tfile.read(77) + tfile2.write(read_buffer) # read the rest of the file, it's the codestream. codestream = tfile.read() # Write the asoc superbox. # Length = 36, id is 'asoc'. - buffer = struct.pack('>I4s', int(56), b'asoc') - tfile2.write(buffer) + write_buffer = struct.pack('>I4s', int(56), b'asoc') + tfile2.write(write_buffer) # Write the contained label box - buffer = struct.pack('>I4s', int(13), b'lbl ') - tfile2.write(buffer) + write_buffer = struct.pack('>I4s', int(13), b'lbl ') + tfile2.write(write_buffer) tfile2.write('label'.encode()) # Write the xml box # Length = 36, id is 'xml '. - buffer = struct.pack('>I4s', int(35), b'xml ') - tfile2.write(buffer) + write_buffer = struct.pack('>I4s', int(35), b'xml ') + tfile2.write(write_buffer) - buffer = 'this is a test' - buffer = buffer.encode() - tfile2.write(buffer) + write_buffer = 'this is a test' + write_buffer = write_buffer.encode() + tfile2.write(write_buffer) # Now append the codestream. tfile2.write(codestream) @@ -678,10 +710,10 @@ class TestJp2k(unittest.TestCase): @unittest.skipIf(OPENJP2_IS_V2_OFFICIAL, "Segfault on official v2.0.0 release.") def test_openjpeg_library_message(self): - # Verify the error message produced by the openjpeg library. + """Verify the error message produced by the openjpeg library""" # This will confirm that the error callback mechanism is working. - with open(self.jp2file, 'rb') as fp: - data = fp.read() + with open(self.jp2file, 'rb') as fptr: + data = fptr.read() with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: # Codestream starts at byte 3127. SIZ marker at 3137. # COD marker at 3186. Subsampling at 3180. @@ -705,13 +737,13 @@ class TestJp2k(unittest.TestCase): :\sdx=1\sdy=0''', re.VERBOSE) if sys.hexversion < 0x03020000: with self.assertRaisesRegexp((IOError, OSError), regexp): - d = j.read(rlevel=1) + j.read(rlevel=1) else: with self.assertRaisesRegex((IOError, OSError), regexp): - d = j.read(rlevel=1) + j.read(rlevel=1) def test_xmp_attribute(self): - # Verify that we can read the XMP packet in our shipping example file. + """Verify the XMP packet in the shipping example file can be read.""" j = Jp2k(self.jp2file) xmp = j.box[4].data ns0 = '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}' @@ -723,7 +755,7 @@ class TestJp2k(unittest.TestCase): @unittest.skipIf(os.name == "nt", "NamedTemporaryFile issue on windows") def test_unrecognized_exif_tag(self): - # An unrecognized exif tag should be handled gracefully. + """An unrecognized exif tag should be handled gracefully.""" with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: shutil.copyfile(self.jp2file, tfile.name) @@ -733,10 +765,10 @@ class TestJp2k(unittest.TestCase): # the the Image IFD number of tags, where we finally find the first # tag, "Make" (271). We'll corrupt it by changing it into 171, # which does not correspond to any known Exif Image tag. - with open(tfile.name, 'r+b') as fp: - fp.seek(117) - buffer = struct.pack('