refactor of test suite

glymur/codestream.py

@@ -642,7 +642,7 @@ class Codestream(object):
         srgn = data[1]
         sprgn = data[2]
 
-        return RGNsegment(length, offset, crgn, srgn, sprgn)
+        return RGNsegment(crgn, srgn, sprgn, length, offset)
 
     def _parse_siz_segment(self, fptr):
         """Parse the SIZ segment.
@@ -1463,7 +1463,7 @@ class RGNsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
-    def __init__(self, length, offset, crgn, srgn, sprgn):
+    def __init__(self, crgn, srgn, sprgn, length=-1, offset=-1):
         Segment.__init__(self, marker_id='RGN')
         self.length = length
         self.offset = offset
@@ -1726,7 +1726,7 @@ class SOTsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
-    def __init__(self, isot, psot, tpsot, tnsot, length, offset):
+    def __init__(self, isot, psot, tpsot, tnsot, length=-1, offset=-1):
         Segment.__init__(self, marker_id='SOT')
         self.isot = isot
         self.psot = psot

glymur/test/fixtures.py

@@ -5,6 +5,7 @@ import os
 import re
 import sys
 import textwrap
+import unittest
 import warnings
 
 import numpy as np
@@ -24,6 +25,124 @@ elif re.match('1.[0-6]', six.__version__) is not None:
     WARNING_INFRASTRUCTURE_ISSUE = True
     WARNING_INFRASTRUCTURE_MSG = "Cannot use with this version of six"
 
+class MetadataBase(unittest.TestCase):
+    """
+    Base class for testing metadata.
+
+    This class has helper routines defined for testing metadata so that it can
+    be subclassed and used easily.
+    """
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def verify_codeblock_style(self, actual, style):
+        """
+        Verify the code-block style for SPcod and SPcoc parameters.
+
+        This information is stored in a single byte.  Please reference
+        Table A-17 in FCD15444-1
+        """
+        expected = 0
+        if style[0]:
+            # Selective arithmetic coding bypass
+            expected |= 0x01
+        if style[1]:
+            # Reset context probabilities
+            expected |= 0x02
+        if style[2]:
+            # Termination on each coding pass
+            expected |= 0x04
+        if style[3]:
+            # Vertically causal context
+            expected |= 0x08
+        if style[4]:
+            # Predictable termination
+            expected |= 0x10
+        if style[5]:
+            # Segmentation symbols
+            expected |= 0x20
+        self.assertEqual(actual, expected)
+
+    def verifySignatureBox(self, box):
+        """
+        The signature box is a constant.
+        """
+        self.assertEqual(box.signature, (13, 10, 135, 10))
+
+    def verify_filetype_box(self, actual, expected):
+        """
+        All JP2 files should have a brand reading 'jp2 ' and just a single
+        entry in the compatibility list, also 'jp2 '.  JPX files can have more
+        compatibility items.
+        """
+        self.assertEqual(actual.brand, expected.brand)
+        self.assertEqual(actual.minor_version, expected.minor_version)
+        self.assertEqual(actual.minor_version, 0)
+        for cl in expected.compatibility_list:
+            self.assertIn(cl, actual.compatibility_list)
+
+    def verifyRGNsegment(self, actual, expected):
+        """
+        verify the fields of a RGN segment
+        """
+        self.assertEqual(actual.crgn, expected.crgn) # 0 = component
+        self.assertEqual(actual.srgn, expected.srgn) # 0 = implicit
+        self.assertEqual(actual.sprgn, expected.sprgn)
+
+    def verifySOTsegment(self, actual, expected):
+        """
+        verify the fields of a SOT (start of tile) segment
+        """
+        self.assertEqual(actual.isot, expected.isot)
+        self.assertEqual(actual.psot, expected.psot)
+        self.assertEqual(actual.tpsot, expected.tpsot)
+        self.assertEqual(actual.tnsot, expected.tnsot)
+
+    def verifyCMEsegment(self, actual, expected):
+        """
+        verify the fields of a CME (comment) segment
+        """
+        self.assertEqual(actual.rcme, expected.rcme)
+        self.assertEqual(actual.ccme, expected.ccme)
+
+    def verifySizSegment(self, actual, expected):
+        """
+        Verify the fields of the SIZ segment.
+        """
+        for field in ['rsiz', 'xsiz', 'ysiz', 'xosiz', 'yosiz', 'xtsiz', 
+                'ytsiz', 'xtosiz', 'ytosiz', 'bitdepth', 'xrsiz', 'yrsiz']:
+            self.assertEqual(getattr(actual, field), getattr(expected, field))
+
+    def verifyImageHeaderBox(self, box1, box2):
+        self.assertEqual(box1.height,             box2.height)
+        self.assertEqual(box1.width,              box2.width)
+        self.assertEqual(box1.num_components,     box2.num_components)
+        self.assertEqual(box1.bits_per_component, box2.bits_per_component)
+        self.assertEqual(box1.signed,             box2.signed)
+        self.assertEqual(box1.compression,        box2.compression)
+        self.assertEqual(box1.colorspace_unknown, box2.colorspace_unknown)
+        self.assertEqual(box1.ip_provided,        box2.ip_provided)
+
+    def verifyColourSpecificationBox(self, actual, expected):
+        """
+        Does not currently check icc profiles.
+        """
+        self.assertEqual(actual.method,        expected.method)
+        self.assertEqual(actual.precedence,    expected.precedence)
+        self.assertEqual(actual.approximation, expected.approximation)
+
+        if expected.colorspace is None:
+            self.assertIsNone(actual.colorspace)
+            self.assertIsNotNone(actual.icc_profile)
+        else:
+            self.assertEqual(actual.colorspace, expected.colorspace)
+            self.assertIsNone(actual.icc_profile)
+        
+
 # The Python XMP Toolkit may be used for XMP UUIDs, but only if available and
 # if the version is at least 2.0.0.
 try:

glymur/test/test_jp2box.py

@@ -35,8 +35,10 @@ from glymur.jp2box import JPEG2000SignatureBox
 from glymur.core import COLOR, OPACITY
 from glymur.core import RED, GREEN, BLUE, GREY, WHOLE_IMAGE
 
-from .fixtures import opj_data_file
+from .fixtures import (
-from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
+        WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
+        MetadataBase
+)
 
 try:
     FORMAT_CORPUS_DATA_ROOT = os.environ['FORMAT_CORPUS_DATA_ROOT']
@@ -1039,7 +1041,7 @@ class TestJp2Boxes(unittest.TestCase):
                          j.box[5].offset + 8)
 
 
-class TestRepr(unittest.TestCase):
+class TestRepr(MetadataBase):
     """Tests for __repr__ methods."""
     def test_default_jp2k(self):
         """Should be able to eval a JPEG2000SignatureBox"""
@@ -1109,10 +1111,7 @@ class TestRepr(unittest.TestCase):
 
         # Test the representation instantiation.
         newbox = eval(repr(ftyp))
-        self.assertTrue(isinstance(newbox, glymur.jp2box.FileTypeBox))
+        self.verify_filetype_box(newbox, FileTypeBox())
-        self.assertEqual(newbox.brand, 'jp2 ')
-        self.assertEqual(newbox.minor_version, 0)
-        self.assertEqual(newbox.compatibility_list, ['jp2 '])
 
     def test_colourspecification_box(self):
         """Verify __repr__ method on colr box."""

glymur/test/test_opj_suite.py

@@ -33,12 +33,15 @@ import unittest
 
 import numpy as np
 
-from glymur import Jp2k
 import glymur
+from glymur import Jp2k
+from glymur.jp2box import FileTypeBox, ImageHeaderBox, ColourSpecificationBox
 
-from .fixtures import OPJ_DATA_ROOT
+from .fixtures import (
-from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
+        OPJ_DATA_ROOT, MetadataBase,
-from .fixtures import mse, peak_tolerance, read_pgx, opj_data_file
+        WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
+        mse, peak_tolerance, read_pgx, opj_data_file
+)
 
 
 @unittest.skipIf(OPJ_DATA_ROOT is None,
@@ -298,7 +301,7 @@ class TestSuite(unittest.TestCase):
 @unittest.skipIf(OPJ_DATA_ROOT is None,
                  "OPJ_DATA_ROOT environment variable not set")
 @unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
-class TestSuiteWarns(unittest.TestCase):
+class TestSuiteWarns(MetadataBase):
     """
     Identical setup to above, but these tests issue warnings.
     """
@@ -394,30 +397,13 @@ class TestSuiteWarns(unittest.TestCase):
 
         # Signature box.  Check for corruption.
         self.assertEqual(jp2.box[0].signature, (13, 10, 135, 10))
+        self.verify_filetype_box(jp2.box[1], FileTypeBox())
 
-        # File type box.
+        expected = ImageHeaderBox(152, 203, num_components=3)
-        self.assertEqual(jp2.box[1].brand, 'jp2 ')
+        self.verifyImageHeaderBox(jp2.box[2].box[0], expected)
-        self.assertEqual(jp2.box[1].minor_version, 0)
-        self.assertEqual(jp2.box[1].compatibility_list[0], 'jp2 ')
 
-        # Jp2 Header
+        expected = ColourSpecificationBox(colorspace=glymur.core.SRGB)
-        # Image header
+        self.verifyColourSpecificationBox(jp2.box[2].box[1], expected)
-        self.assertEqual(jp2.box[2].box[0].height, 152)
-        self.assertEqual(jp2.box[2].box[0].width, 203)
-        self.assertEqual(jp2.box[2].box[0].num_components, 3)
-        self.assertEqual(jp2.box[2].box[0].bits_per_component, 8)
-        self.assertEqual(jp2.box[2].box[0].signed, False)
-        self.assertEqual(jp2.box[2].box[0].compression, 7)   # wavelet
-        self.assertEqual(jp2.box[2].box[0].colorspace_unknown, False)
-        self.assertEqual(jp2.box[2].box[0].ip_provided, False)
-
-        # Jp2 Header
-        # Colour specification
-        self.assertEqual(jp2.box[2].box[1].method,
-                         glymur.core.ENUMERATED_COLORSPACE)
-        self.assertEqual(jp2.box[2].box[1].precedence, 0)
-        self.assertEqual(jp2.box[2].box[1].approximation, 0)  # not allowed?
-        self.assertEqual(jp2.box[2].box[1].colorspace, glymur.core.SRGB)
 
         c = jp2.box[3].main_header
 
@@ -425,32 +411,17 @@ class TestSuiteWarns(unittest.TestCase):
         expected = ['SOC', 'SIZ', 'CME', 'COD', 'QCD', 'QCC', 'QCC']
         self.assertEqual(ids, expected)
 
-        # SIZ: Image and tile size
+        kwargs = {'rsiz': 0, 'xysiz': (203, 152), 'xyosiz': (0, 0),
-        # Profile:
+                'xytsiz': (203, 152), 'xytosiz': (0, 0), 'bitdepth': (8, 8, 8),
-        self.assertEqual(c.segment[1].rsiz, 0)
+                'signed': (False, False, False),
-        # Reference grid size
+                'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-        self.assertEqual(c.segment[1].xsiz, 203)
+        self.verifySizSegment(c.segment[1],
-        self.assertEqual(c.segment[1].ysiz, 152)
+                glymur.codestream.SIZsegment(**kwargs))
-        # Reference grid offset
-        self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
-        # Tile size
-        self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz), (203, 152))
-        # Tile offset
-        self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
-        # bitdepth
-        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
-        # signed
-        self.assertEqual(c.segment[1].signed, (False, False, False))
-        # subsampling
-        self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
-                         [(1, 1)] * 3)
 
-        # COM: comment
+        pargs = (glymur.core.RCME_ISO_8859_1,
-        # Registration
+                "Creator: JasPer Version 1.701.0".encode())
-        self.assertEqual(c.segment[2].rcme, glymur.core.RCME_ISO_8859_1)
+        self.verifyCMEsegment(c.segment[2],
-        # Comment value
+                glymur.codestream.CMEsegment(*pargs))
-        self.assertEqual(c.segment[2].ccme.decode('latin-1'),
-                         "Creator: JasPer Version 1.701.0")
 
         # COD: Coding style default
         self.assertFalse(c.segment[3].scod & 2)  # no sop
@@ -461,18 +432,8 @@ class TestSuiteWarns(unittest.TestCase):
         self.assertEqual(c.segment[3].spcod[4], 5)  # level
         self.assertEqual(tuple(c.segment[3].code_block_size),
                          (64, 64))  # cblk
-        # Selective arithmetic coding bypass
+        self.verify_codeblock_style(c.segment[3].spcod[7],
-        self.assertFalse(c.segment[3].spcod[7] & 0x01)
+                [False, False, False, False, False, False])
-        # Reset context probabilities
-        self.assertFalse(c.segment[3].spcod[7] & 0x02)
-        # Termination on each coding pass
-        self.assertFalse(c.segment[3].spcod[7] & 0x04)
-        # Vertically causal context
-        self.assertFalse(c.segment[3].spcod[7] & 0x08)
-        # Predictable termination
-        self.assertFalse(c.segment[3].spcod[7] & 0x0010)
-        # Segmentation symbols
-        self.assertFalse(c.segment[3].spcod[7] & 0x0020)
         self.assertEqual(c.segment[3].spcod[8],
                          glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
         self.assertEqual(len(c.segment[3].spcod), 9)

glymur/test/test_opj_suite_write.py

@@ -27,90 +27,37 @@ from . import fixtures
 from glymur import Jp2k
 import glymur
 
-class CinemaBase(unittest.TestCase):
+class CinemaBase(fixtures.MetadataBase):
+
+    def verify_cinema_cod(self, cod_segment):
+
+        self.assertFalse(cod_segment.scod & 2)  # no sop
+        self.assertFalse(cod_segment.scod & 4)  # no eph
+        self.assertEqual(cod_segment.spcod[0], glymur.core.CPRL)
+        self.assertEqual(cod_segment.layers, 1)
+        self.assertEqual(cod_segment.spcod[3], 1)  # mct
+        self.assertEqual(cod_segment.spcod[4], 5)  # levels
+        self.assertEqual(tuple(cod_segment.code_block_size), (32, 32))  # cblksz
 
     def check_cinema4k_codestream(self, codestream, image_size):
-        """Common out for cinema2k tests."""
-        # SIZ: Image and tile size
-        # Profile:  "3" means cinema2K
-        self.assertEqual(codestream.segment[1].rsiz, 4)
-        # Reference grid size
-        self.assertEqual((codestream.segment[1].xsiz,
-                          codestream.segment[1].ysiz),
-                         image_size)
-        # Reference grid offset
-        self.assertEqual((codestream.segment[1].xosiz,
-                          codestream.segment[1].yosiz), (0, 0))
-        # Tile size
-        self.assertEqual((codestream.segment[1].xtsiz,
-                          codestream.segment[1].ytsiz),
-                         image_size)
-        # Tile offset
-        self.assertEqual((codestream.segment[1].xtosiz,
-                          codestream.segment[1].ytosiz),
-                         (0, 0))
-        # bitdepth
-        self.assertEqual(codestream.segment[1].bitdepth, (12, 12, 12))
-        # signed
-        self.assertEqual(codestream.segment[1].signed,
-                         (False, False, False))
-        # subsampling
-        self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                  codestream.segment[1].yrsiz)),
-                         [(1, 1)] * 3)
-
-        # COD: Coding style default
-        self.assertFalse(codestream.segment[2].scod & 2)  # no sop
-        self.assertFalse(codestream.segment[2].scod & 4)  # no eph
-        self.assertEqual(codestream.segment[2].spcod[0], glymur.core.CPRL)
-        self.assertEqual(codestream.segment[2].layers, 1)
-        self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
-        self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
-        self.assertEqual(tuple(codestream.segment[2].code_block_size),
-                         (32, 32))  # cblksz
 
+        kwargs = {'rsiz': 4, 'xysiz': image_size, 'xyosiz': (0, 0),
+                'xytsiz': image_size, 'xytosiz': (0, 0),
+                'bitdepth': (12, 12, 12), 'signed': (False, False, False),
+                'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
+        self.verifySizSegment(c.segment[1], glymur.codestream.SIZsegment(**kwargs))
 
+        self.verify_cinema_cod(codestream.segment[2])
 
     def check_cinema2k_codestream(self, codestream, image_size):
-        """Common out for cinema2k tests."""
-        # SIZ: Image and tile size
-        # Profile:  "3" means cinema2K
-        self.assertEqual(codestream.segment[1].rsiz, 3)
-        # Reference grid size
-        self.assertEqual((codestream.segment[1].xsiz,
-                          codestream.segment[1].ysiz),
-                         image_size)
-        # Reference grid offset
-        self.assertEqual((codestream.segment[1].xosiz,
-                          codestream.segment[1].yosiz), (0, 0))
-        # Tile size
-        self.assertEqual((codestream.segment[1].xtsiz,
-                          codestream.segment[1].ytsiz),
-                         image_size)
-        # Tile offset
-        self.assertEqual((codestream.segment[1].xtosiz,
-                          codestream.segment[1].ytosiz),
-                         (0, 0))
-        # bitdepth
-        self.assertEqual(codestream.segment[1].bitdepth, (12, 12, 12))
-        # signed
-        self.assertEqual(codestream.segment[1].signed,
-                         (False, False, False))
-        # subsampling
-        self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                  codestream.segment[1].yrsiz)),
-                         [(1, 1)] * 3)
 
-        # COD: Coding style default
+        kwargs = {'rsiz': 3, 'xysiz': image_size, 'xyosiz': (0, 0),
-        self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+                'xytsiz': image_size, 'xytosiz': (0, 0),
-        self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+                'bitdepth': (12, 12, 12), 'signed': (False, False, False),
-        self.assertEqual(codestream.segment[2].spcod[0], glymur.core.CPRL)
+                'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-        self.assertEqual(codestream.segment[2].layers, 1)
+        self.verifySizSegment(c.segment[1], glymur.codestream.SIZsegment(**kwargs))
-        self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
-        self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
-        self.assertEqual(tuple(codestream.segment[2].code_block_size),
-                         (32, 32))  # cblksz
 
+        self.verify_cinema_cod(codestream.segment[2])
 
 
 @unittest.skipIf(NO_SKIMAGE_FREEIMAGE_SUPPORT,
@@ -274,7 +221,7 @@ class TestSuiteNegative2pointzero(unittest.TestCase):
 @unittest.skipIf(NO_READ_BACKEND, NO_READ_BACKEND_MSG)
 @unittest.skipIf(OPJ_DATA_ROOT is None,
                  "OPJ_DATA_ROOT environment variable not set")
-class TestSuiteWrite(unittest.TestCase):
+class TestSuiteWrite(fixtures.MetadataBase):
     """Tests for writing with openjp2 backend.
 
     These tests either roughly correspond with those tests with similar names
@@ -308,60 +255,28 @@ class TestSuiteWrite(unittest.TestCase):
             j.write(data, cratios=[200, 100, 50])
 
             # Should be three layers.
-            codestream = j.get_codestream()
+            c = j.get_codestream()
 
-            # SIZ: Image and tile size
+        kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                'xytsiz': (640, 480), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+        self.verifySizSegment(c.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (640, 480))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (640, 480))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
-            # COD: Coding style default
+        # COD: Coding style default
-            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+        self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+        self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+        self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(codestream.segment[2].layers, 3)  # layers = 3
+        self.assertEqual(c.segment[2].layers, 3)  # layers = 3
-            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+        self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+        self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(codestream.segment[2].code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
-                             (64, 64))  # cblksz
+                         (64, 64))  # cblksz
-            # Selective arithmetic coding bypass
+        self.verify_codeblock_style(c.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                [False, False, False, False, False, False])
-            # Reset context probabilities
+        self.assertEqual(c.segment[2].spcod[8],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
+                         glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            # Termination on each coding pass
+        self.assertEqual(len(c.segment[2].spcod), 9)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(codestream.segment[2].spcod[8],
-                             glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     def test_NR_ENC_Bretagne1_ppm_2_encode(self):
         """NR-ENC-Bretagne1.ppm-2-encode"""
@@ -374,34 +289,11 @@ class TestSuiteWrite(unittest.TestCase):
             # Should be three layers.
             codestream = j.get_codestream()
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (640, 480), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (640, 480))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (640, 480))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth,
-                             (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -412,18 +304,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 1)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding bypass
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # Reset context probabilities
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -440,33 +322,11 @@ class TestSuiteWrite(unittest.TestCase):
             # Should be three layers.
             codestream = j.get_codestream()
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (640, 480), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (640, 480))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (640, 480))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -477,18 +337,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (16, 16))  # cblksz
-            # Selective arithmetic coding bypass
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # Reset context probabilities
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(codestream.segment[2].precinct_size,
@@ -510,33 +360,11 @@ class TestSuiteWrite(unittest.TestCase):
             # Should be three layers.
             codestream = j.get_codestream()
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (640, 480), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (data.shape[1], data.shape[0]))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size.  Reported as XY, not RC.
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (640, 480))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -547,18 +375,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (32, 32))  # cblksz
-            # Selective arithmetic coding bypass
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # Reset context probabilities
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(codestream.segment[2].precinct_size,
@@ -574,33 +392,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = j.get_codestream()
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (127, 127), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (data.shape[1], data.shape[0]))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (127, 127))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -611,18 +407,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding bypass
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # Reset context probabilities
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -637,33 +423,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = j.get_codestream(header_only=False)
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (5183, 3887), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (5183, 3887), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(2, 2, 2), (2, 2, 2)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (5183, 3887))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (5183, 3887))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(2, 2)] * 3)
 
             # COD: Coding style default
             self.assertTrue(codestream.segment[2].scod & 2)  # sop
@@ -674,18 +438,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding bypass
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # Reset context probabilities
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -705,33 +459,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = j.get_codestream(header_only=False)
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (2592, 1944), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (2592, 1944))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (2592, 1944))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -742,18 +474,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                             (64, 64))  # cblksz
-            # Selective arithmetic coding BYPASS
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, True, True, False, False, True])
-            # RESET context probabilities (RESET)
-            self.assertTrue(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass, RESTART(TERMALL)
-            self.assertTrue(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context (VSC)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertTrue(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -772,34 +494,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = j.get_codestream(header_only=False)
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (2742, 2244), 'xyosiz': (150, 300),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (2742, 2244), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (2742, 2244))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz),
-                             (150, 300))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (2742, 2244))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -810,18 +509,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding BYPASS
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # RESET context probabilities (RESET)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context (VSC)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -836,33 +525,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = j.get_codestream(header_only=False)
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (2592, 1944), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (2592, 1944))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (2592, 1944))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -873,18 +540,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding BYPASS
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # RESET context probabilities (RESET)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context (VSC)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -899,33 +556,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = j.get_codestream(header_only=False)
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (640, 480), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (640, 480))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (640, 480))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -936,18 +571,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding BYPASS
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # RESET context probabilities (RESET)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context (VSC)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -994,34 +619,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = jp2.box[3].main_header
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (640, 480), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (8, 8, 8), 'signed': (False, False, False),
-            # Reference grid size
+                    'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (640, 480))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz),
-                             (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (640, 480))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
-            # signed
-            self.assertEqual(codestream.segment[1].signed,
-                             (False, False, False))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)] * 3)
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -1032,18 +634,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 2)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding BYPASS
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # RESET context probabilities (RESET)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context (VSC)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)
@@ -1060,32 +652,11 @@ class TestSuiteWrite(unittest.TestCase):
 
             codestream = j.get_codestream(header_only=False)
 
-            # SIZ: Image and tile size
+            kwargs = {'rsiz': 0, 'xysiz': (1024, 1024), 'xyosiz': (0, 0),
-            # Profile:  "0" means profile 2
+                    'xytsiz': (1024, 1024), 'xytosiz': (0, 0),
-            self.assertEqual(codestream.segment[1].rsiz, 0)
+                    'bitdepth': (16,), 'signed': (False,),
-            # Reference grid size
+                    'xyrsiz': [(1,), (1,)]}
-            self.assertEqual((codestream.segment[1].xsiz,
+            self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
-                              codestream.segment[1].ysiz),
-                             (1024, 1024))
-            # Reference grid offset
-            self.assertEqual((codestream.segment[1].xosiz,
-                              codestream.segment[1].yosiz), (0, 0))
-            # Tile size
-            self.assertEqual((codestream.segment[1].xtsiz,
-                              codestream.segment[1].ytsiz),
-                             (1024, 1024))
-            # Tile offset
-            self.assertEqual((codestream.segment[1].xtosiz,
-                              codestream.segment[1].ytosiz),
-                             (0, 0))
-            # bitdepth
-            self.assertEqual(codestream.segment[1].bitdepth, (16,))
-            # signed
-            self.assertEqual(codestream.segment[1].signed, (False,))
-            # subsampling
-            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
-                                      codestream.segment[1].yrsiz)),
-                             [(1, 1)])
 
             # COD: Coding style default
             self.assertFalse(codestream.segment[2].scod & 2)  # no sop
@@ -1096,18 +667,8 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
             self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
-            # Selective arithmetic coding BYPASS
+            self.verify_codeblock_style(codestream.segment[2].spcod[7],
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
+                    [False, False, False, False, False, False])
-            # RESET context probabilities (RESET)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
-            # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
-            # Vertically causal context (VSC)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
-            # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
-            # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
             self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
             self.assertEqual(len(codestream.segment[2].spcod), 9)