def testDescrStructure(self):
        """Check structure of the descr list.
        """

        common.verbosePrint('\nTesting descr structure')
        for item in nriterators.flattenDescr(self.descr, check=True):
            self.failIfEqual(item, None)

    def testNamesStructure(self):
        """Check the structure of the names list.
        """

        common.verbosePrint('\nTesting names structure')
        for item in nriterators.flattenNames(self.names):
            self.failIfEqual(item, None)

    def testSubFieldNames(self):
        """Check the syntax of the names list components.
        """

        common.verbosePrint('\nTesting names list decomposition')
        subnames = [sn for sn in nriterators.getSubNames(self.names)]
        self.assertEqual(subnames, self.subnames)

    def testFormatsStructure(self):
        """Check the structure of the formats list.
        """

        common.verbosePrint('\nTesting formats structure')
        for f in nriterators.flattenFormats(self.formats, check=True):
            self.failIfEqual(f, None)

    def test01_rowAppend(self):
        """Appending enumerated values using ``row.append()``."""

        tbl = self.h5file.createTable(
            '/', 'test', self._description(), title=self._getMethodName())

        appended = [
            (10, self.valueInEnum),
            (20, self.valueOutOfEnum)]

        row = tbl.row

        row['rid'] = appended[0][0]
        row['rcolor'] = appended[0][1]
        row.append()

        row['rid'] = appended[1][0]
        self.assertRaises(
            ValueError, operator.setitem, row, 'rcolor', appended[1][1])

        tbl.flush()
        tbl.flavor = 'python'
        read = tbl.read()
        common.verbosePrint(
            "* appended value: %s\n"
            "* read value: %s\n"
            % (appended[:-1], read) )
        self.assertEqual(
            appended[:-1], read, "Written and read values differ.")

    def testBufferStructureWDescr(self):
        """Check the structure of a buffer row using the descr list.
        """

        common.verbosePrint('\nTesting buffer row structure with zipBufferDescr')
        mix = [item for item in nriterators.zipBufferDescr(self.row,
            self.descr)]
        self.assertEqual(mix, zip(self.flat_row, self.flat_formats))

    def testNamesFromDescr(self):
        """Retrieves the names list from the descr list.
        """

        # Check getNamesFromDescr function
        common.verbosePrint('\nTesting getNamesFromDescr function')
        new_names = \
            [item for item in nriterators.getNamesFromDescr(self.descr)]
        self.assertEqual(self.names, new_names)

    def testMakeDescr(self):
        """Check the generation of a descr from formats and names.
        """

        common.verbosePrint('\nTesting getDescr function')
        mix = [f for f in nriterators.getDescr(None, self.formats)]
        self.assertEqual(mix, self.autoNamedDescr)
        mix = \
            [f for f in nriterators.getDescr(self.names, self.formats)]
        self.assertEqual(mix, self.descr)

    def testFieldsDescr(self):
        """Check the checkFieldsInDescr function.
        """

        common.verbosePrint( """\nTesting the field names syntax in a """
            """sample descr list""")
        descr = [('position', 'Int64'),
            ('info', [('name', [('first','a5'), ('second','a5')]),
               ('coord', [('x/equis','Float32'), ('y', 'f4'), ('z', 'f4')])])]
        self.assertRaises(ValueError, nra.nestedrecords._checkFieldsInDescr,
            descr)

 def newmethod(self, *args, **kwargs):
     self._verboseHeader()
     try:
         return oldmethod(self, *args, **kwargs)
     except SilentlySkipTest as se:
         if se.args:
             msg = se.args[0]
         else:
             msg = "<skipped>"
         common.verbosePrint("\nSkipped test: %s" % msg)
     finally:
         common.verbosePrint('')  # separator line between tests

    def test02_append(self):
        """Appending enumerated values using ``table.append()``."""

        tbl = self.h5file.create_table("/", "test", self._description(), title=self._getMethodName())

        appended = [(10, self.valueInEnum), (20, self.valueOutOfEnum)]

        tbl.append(appended)
        tbl.flush()
        tbl.flavor = "python"
        read = tbl.read()
        common.verbosePrint("* appended value: %s\n" "* read value: %s\n" % (appended, read))
        self.assertEqual(appended, read, "Written and read values differ.")

    def testArrayUniqueSyntax(self):
        """Check the onlyOneSyntax function.
        """

        common.verbosePrint( '\nTesting the uniqueness of the array syntax')
        self.assertEqual(nra.nestedrecords._onlyOneSyntax(self.descr, None,
            None), None)
        self.assertEqual(nra.nestedrecords._onlyOneSyntax(None,
            self.formats, None), None)
        self.assertRaises(ValueError, nra.nestedrecords._onlyOneSyntax,
            self.descr, self.formats, None)
        self.assertRaises(ValueError, nra.nestedrecords._onlyOneSyntax,
            self.descr, None, self.names)

    def test03_setitem(self):
        """Changing enumerated values using ``vlarray.__setitem__()``."""

        vlarr = self.h5file.create_vlarray("/", "test", self._atom(), title=self._getMethodName())
        vlarr.flavor = "python"

        appended = (self.valueInEnum, self.valueInEnum)
        vlarr.append(appended)

        written = [self.valueInEnum, self.valueOutOfEnum]
        vlarr[0] = written
        read = vlarr.read()
        common.verbosePrint("* written value: %s\n" "* read value: %s\n" % (written, read))
        self.assertEqual(written, read[0], "Written and read values differ.")

    def test01_append(self):
        """Appending scalar elements of enumerated values."""

        vlarr = self.h5file.create_vlarray("/", "test", self._atom(), title=self._getMethodName())
        vlarr.flavor = "python"

        appended = [[self.valueInEnum], [self.valueInEnum, self.valueOutOfEnum]]

        vlarr.append(appended[0])
        vlarr.append(appended[1])
        vlarr.flush()
        read = vlarr.read()
        common.verbosePrint("* appended value: %s\n" "* read value: %s\n" % (appended, read))
        self.assertEqual(appended, read, "Written and read values differ.")

    def test(self):
        """Reading scalar arrays (see #98)."""

        arr = self.h5file.createArray('/', 'scalar_na', 1234)
        arr.flavor = 'numarray'

        self._reopen()

        arr = self.h5file.root.scalar_na

        common.verbosePrint("* %r == %r ?" % (arr.read(), array(1234)))
        self.assertTrue(all(arr.read() == array(1234)))
        common.verbosePrint("* %r == %r ?" % (arr[()], array(1234)))
        self.assertTrue(all(arr[()] == 1234))

    def testArrayFormats(self):
        """Check the checkFormats function.
        """

        common.verbosePrint( '\nTesting samples of formats description')
        formats = 'formats should be a list'
        self.assertRaises(TypeError, nra.nestedrecords._checkFormats,
            formats)
        # Formats must be a list of strings or sequences
        formats = [25,
            [['a5', 'a5'],['Float32', 'f4', 'f4']]]
        self.assertRaises(TypeError, nra.nestedrecords._checkFormats,
            formats)
        # If formats is OK checkFormats returns None
        self.assertEqual(nra.nestedrecords._checkFormats(self.formats),
            None)

    def test05_where(self):
        """Searching enumerated data."""

        tbl = self.h5file.create_table("/", "test", self._description(), title=self._getMethodName())

        appended = [(10, self.valueInEnum), (20, self.valueInEnum), (30, self.valueOutOfEnum)]
        tbl.append(appended)
        tbl.flush()

        searched = [(row["rid"], row["rcolor"]) for row in tbl.where("rcolor == v", {"v": self.valueInEnum})]
        common.verbosePrint(
            "* ``valueInEnum``: %s\n"
            "* ``rcolor`` column: ``%s``\n"
            "* ``searched``: %s\n"
            "* Should look like: %s\n" % (self.valueInEnum, tbl.cols.rcolor, searched, appended[:-1])
        )
        self.assertEqual(searched, appended[:-1], "Search returned incorrect results.")

    def test02_appendMD(self):
        """Appending multi-dimensional elements of enumerated values."""

        vlarr = self.h5file.createVLArray(
            '/', 'test', self._atom((2,)),
            title=self._getMethodName() )
        vlarr.flavor = 'python'

        appended = [
            [[self.valueInEnum, self.valueInEnum],],
            [[self.valueInEnum, self.valueOutOfEnum],
             [self.valueInEnum, self.valueInEnum]]]

        vlarr.append(appended[0])
        vlarr.append(appended[1])
        vlarr.flush()
        read = vlarr.read()
        common.verbosePrint(
            "* appended value: %s\n"
            "* read value: %s\n"
            % (appended, read) )
        self.assertEqual(appended, read, "Written and read values differ.")

    def testArrayNames(self):
        """Check the checkNames function.
        """

        common.verbosePrint( '\nTesting samples of names description')
        names = 'names should be a list'
        self.assertRaises(TypeError, nra.nestedrecords._checkNames,
            names)
        # Names must be a list of strings or 2-tuples
        names = [25,
            ('info', [('name', ['first', 'second']),
                                ('coord', ['x', 'y', 'z'])])]
        self.assertRaises(TypeError, nra.nestedrecords._checkNames, names)

        # Names must be unique at any given level
        names = ['position',
            ('info', [('name', ['first', 'second']),
                                ('coord', ['x', 'y', 'y'])])]
        self.assertRaises(ValueError, nra.nestedrecords._checkNames, names)

        # If names is OK checkNames returns None
        self.assertEqual(nra.nestedrecords._checkNames(self.names), None)

    def testNamesUniqueness(self):
        """Check that names are unique at every level of the names list.
        """

        common.verbosePrint('\nTesting checkNamesUniqueness')
        foo = nriterators.checkNamesUniqueness
        badNames = ['info',
        ('info', [('name', ['first', 'second']),
                                ('coord', ['x', 'y', 'z'])])]
        self.assertRaises(ValueError, foo, badNames)
        badNames = ['position',
        ('info', [('coord', ['first', 'second']),
                                ('coord', ['x', 'y', 'z'])])]
        self.assertRaises(ValueError, foo, badNames)
        badNames = ['position',
        ('info', [('name', ['first', 'second']),
                                ('coord', ['x', 'x', 'z'])])]
        self.assertRaises(ValueError, foo, badNames)
        goodNames = ['position',
        ('info', [('info', ['first', 'second']),
                                ('coord', ['x', 'y', 'z'])])]
        self.assertEqual(foo(goodNames), None)