# -*- coding: utf-8 -*-

from __future__ import print_function
from __future__ import absolute_import
import os
import sys
import tempfile

import numpy as np

import tables
from tables import (
    StringCol, BoolCol, FloatCol, ComplexCol, EnumCol,
    Int8Col, UInt8Col, Int16Col, UInt16Col, Int32Col, UInt32Col,
    Int64Col, Float32Col, Float64Col, Time64Col
)
from tables.tests import common
from tables.tests.common import allequal
from tables.tests.common import unittest
from tables.tests.common import PyTablesTestCase as TestCase
from six.moves import range


typecodes = ['b', 'h', 'i', 'l', 'q', 'f', 'd']
# UInt64 checking disabled on win platforms
# because this type is not supported
if sys.platform != 'win32':
    typecodes += ['B', 'H', 'I', 'L', 'Q', 'F', 'D']
else:
    typecodes += ['B', 'H', 'I', 'L', 'F', 'D']
typecodes += ['b1']   # boolean

if hasattr(tables, 'Float16Atom'):
    typecodes.append('e')
if hasattr(tables, 'Float96Atom') or hasattr(tables, 'Float128Atom'):
    typecodes.append('g')
if hasattr(tables, 'Complex192Atom') or hasattr(tables, 'Conplex256Atom'):
    typecodes.append('G')

byteorder = {'little': '<', 'big': '>'}[sys.byteorder]


class BasicTestCase(TestCase):
    """Basic test for all the supported typecodes present in NumPy.

    All of them are included on PyTables.

    """
    endiancheck = 0

    def WriteRead(self, testArray):
        if common.verbose:
            print('\n', '-=' * 30)
            print("Running test for array with typecode '%s'" %
                  testArray.dtype.char, end=' ')
            print("for class check:", self.title)

        # Create an instance of HDF5 Table
        self.h5fname = tempfile.mktemp(".h5")
        try:
            with tables.open_file(self.h5fname, mode="w") as self.h5file:
                self.root = self.h5file.root

                # Create the array under root and name 'somearray'
                a = testArray
                self.h5file.create_array(self.root, 'somearray', a,
                                         "Some array")

            # Re-open the file in read-only mode
            with tables.open_file(self.h5fname, mode="r") as self.h5file:
                self.root = self.h5file.root

                # Read the saved array
                b = self.root.somearray.read()

                # For cases that read returns a python type instead of a
                # numpy type
                if not hasattr(b, "shape"):
                    b = np.np.array(b, dtype=a.dtype.str)

                # Compare them. They should be equal.
                # if not allequal(a,b, "numpy") and common.verbose:
                if common.verbose:
                    print("Array written:", a)
                    print("Array written shape:", a.shape)
                    print("Array written itemsize:", a.itemsize)
                    print("Array written type:", a.dtype.char)
                    print("Array read:", b)
                    print("Array read shape:", b.shape)
                    print("Array read itemsize:", b.itemsize)
                    print("Array read type:", b.dtype.char)

                type_ = self.root.somearray.atom.type

                # Check strictly the array equality
                self.assertEqual(type(a), type(b))
                self.assertEqual(a.shape, b.shape)
                self.assertEqual(a.shape, self.root.somearray.shape)
                self.assertEqual(a.dtype, b.dtype)
                if a.dtype.char[0] == "S":
                    self.assertEqual(type_, "string")
                else:
                    self.assertEqual(a.dtype.base.name, type_)

                self.assertTrue(allequal(a, b, "numpy"))
        finally:
            # Then, delete the file
            if os.path.exists(self.h5fname):
                os.remove(self.h5fname)

    def test00_char(self):
        """Data integrity during recovery (character objects)"""

        a = np.array(self.tupleChar, 'S'+str(len(self.tupleChar)))
        self.WriteRead(a)

    def test01_char_nc(self):
        """Data integrity during recovery (non-contiguous character objects)"""

        a = np.array(self.tupleChar, 'S'+str(len(self.tupleChar)))
        if a.shape == ():
            b = a               # We cannot use the indexing notation
        else:
            b = a[::2]
            # Ensure that this numpy string is non-contiguous
            if a.shape[0] > 2:
                self.assertEqual(b.flags['CONTIGUOUS'], False)
        self.WriteRead(b)

    def test02_types(self):
        """Data integrity during recovery (numerical types)"""

        for typecode in typecodes:
            if self.tupleInt.shape:
                a = self.tupleInt.astype(typecode)
            else:
                # shape is the empty tuple ()
                a = np.array(self.tupleInt, dtype=typecode)
            self.WriteRead(a)

    def test03_types_nc(self):
        """Data integrity during recovery (non-contiguous numerical types)"""

        for typecode in typecodes:
            if self.tupleInt.shape:
                a = self.tupleInt.astype(typecode)
            else:
                # shape is the empty tuple ()
                a = np.array(self.tupleInt, dtype=typecode)

            # This should not be tested for the rank-0 case
            if len(a.shape) == 0:
                raise unittest.SkipTest
            b = a[::2]

            # Ensure that this array is non-contiguous (for non-trivial case)
            if a.shape[0] > 2:
                self.assertEqual(b.flags['CONTIGUOUS'], False)
            self.WriteRead(b)


class Basic0DOneTestCase(BasicTestCase):
    # Rank-0 case
    title = "Rank-0 case 1"
    tupleInt = np.array(3)
    tupleChar = "4"


class Basic0DTwoTestCase(BasicTestCase):
    # Rank-0 case
    title = "Rank-0 case 2"
    tupleInt = np.array(33)
    tupleChar = "44"


class Basic1DOneTestCase(BasicTestCase):
    # 1D case
    title = "Rank-1 case 1"
    tupleInt = np.array((3,))
    tupleChar = ("a",)


class Basic1DTwoTestCase(BasicTestCase):
    # 1D case
    title = "Rank-1 case 2"
    tupleInt = np.array((0, 4))
    tupleChar = ("aaa",)


class Basic1DThreeTestCase(BasicTestCase):
    # 1D case
    title = "Rank-1 case 3"
    tupleInt = np.array((3, 4, 5))
    tupleChar = ("aaaa", "bbb",)


class Basic2DTestCase(BasicTestCase):
    # 2D case
    title = "Rank-2 case 1"
    # tupleInt = reshape(np.array(np.arange((4)**2)), (4,)*2)
    tupleInt = np.ones((4,)*2)
    tupleChar = [["aaa", "ddddd"], ["d", "ss"], ["s", "tt"]]


class Basic10DTestCase(BasicTestCase):
    # 10D case
    title = "Rank-10 case 1"
    # tupleInt = reshape(np.array(np.arange((2)**10)), (2,)*10)
    tupleInt = np.ones((2,)*10)
    # tupleChar = reshape(np.array([1],dtype="S1"),(1,)*10)
    # The next tuple consumes far more time, so this
    # test should be run in common.heavy mode.
    tupleChar = np.array(tupleInt, dtype="S1")


# class Basic32DTestCase(BasicTestCase):
#     # 32D case (maximum)
#     tupleInt = reshape(np.array((22,)), (1,)*32)
#     # Strings seems to be very slow with somewhat large dimensions
#     # This should not be run unless the numarray people address this problem
#     # F. Alted 2006-01-04
#     tupleChar = np.array(tupleInt, dtype="S1")


class GroupsArrayTestCase(common.TempFileMixin, TestCase):
    """This test class checks combinations of arrays with groups.

    It also uses arrays ranks which ranges until 10.

    """

    def test00_iterativeGroups(self):
        """Checking combinations of arrays with groups

        It also uses arrays ranks which ranges until 10.

        """

        if common.verbose:
            print('\n', '-=' * 30)
            print("Running %s.test00_iterativeGroups..." %
                  self.__class__.__name__)

        # Get the root group
        group = self.h5file.root

        i = 1
        for typecode in typecodes:
            # Create an array of typecode, with incrementally bigger ranges
            a = np.ones((2,) * i, typecode)
            # Save it on the HDF5 file
            dsetname = 'array_' + typecode
            if common.verbose:
                print("Creating dataset:", group._g_join(dsetname))
            self.h5file.create_array(group, dsetname, a, "Large array")
            # Create a new group
            group = self.h5file.create_group(group, 'group' + str(i))
            # increment the range for next iteration
            i += 1

        self._reopen()

        # Get the root group
        group = self.h5file.root

        # Get the metadata on the previosly saved arrays
        for i in range(1, len(typecodes)):
            # Create an array for later comparison
            a = np.ones((2,) * i, typecodes[i - 1])
            # Get the dset object hanging from group
            dset = getattr(group, 'array_' + typecodes[i-1])
            # Get the actual array
            b = dset.read()
            if not allequal(a, b, "numpy") and common.verbose:
                print("Array a original. Shape: ==>", a.shape)
                print("Array a original. Data: ==>", a)
                print("Info from dataset:", dset._v_pathname)
                print("  shape ==>", dset.shape, end=' ')
                print("  dtype ==> %s" % dset.dtype)
                print("Array b read from file. Shape: ==>", b.shape, end=' ')
                print(". Type ==> %s" % b.dtype.char)

            self.assertEqual(a.shape, b.shape)
            if np.dtype('l').itemsize == 4:
                if (a.dtype.char == "i" or a.dtype.char == "l"):
                    # Special expection. We have no way to distinguish between
                    # "l" and "i" typecode, and we can consider them the same
                    # to all practical effects
                    self.assertTrue(b.dtype.char == "l" or b.dtype.char == "i")
                elif (a.dtype.char == "I" or a.dtype.char == "L"):
                    # Special expection. We have no way to distinguish between
                    # "L" and "I" typecode, and we can consider them the same
                    # to all practical effects
                    self.assertTrue(b.dtype.char == "L" or b.dtype.char == "I")
                else:
                    self.assertTrue(allequal(a, b, "numpy"))
            elif np.dtype('l').itemsize == 8:
                if (a.dtype.char == "q" or a.dtype.char == "l"):
                    # Special expection. We have no way to distinguish between
                    # "q" and "l" typecode in 64-bit platforms, and we can
                    # consider them the same to all practical effects
                    self.assertTrue(b.dtype.char == "l" or b.dtype.char == "q")
                elif (a.dtype.char == "Q" or a.dtype.char == "L"):
                    # Special expection. We have no way to distinguish between
                    # "Q" and "L" typecode in 64-bit platforms, and we can
                    # consider them the same to all practical effects
                    self.assertTrue(b.dtype.char == "L" or b.dtype.char == "Q")
                else:
                    self.assertTrue(allequal(a, b, "numpy"))

            # Iterate over the next group
            group = getattr(group, 'group' + str(i))

    def test01_largeRankArrays(self):
        """Checking creation of large rank arrays (0 < rank <= 32)

        It also uses arrays ranks which ranges until maxrank.

        """

        # maximum level of recursivity (deepest group level) achieved:
        # maxrank = 32 (for a effective maximum rank of 32)
        # This limit is due to a limit in the HDF5 library.
        minrank = 1
        maxrank = 32

        if common.verbose:
            print('\n', '-=' * 30)
            print("Running %s.test01_largeRankArrays..." %
                  self.__class__.__name__)
            print("Maximum rank for tested arrays:", maxrank)

        group = self.h5file.root
        if common.verbose:
            print("Rank array writing progress: ", end=' ')
        for rank in range(minrank, maxrank + 1):
            # Create an array of integers, with incrementally bigger ranges
            a = np.ones((1,) * rank, 'i')
            if common.verbose:
                print("%3d," % (rank), end=' ')
            self.h5file.create_array(group, "array", a, "Rank: %s" % rank)
            group = self.h5file.create_group(group, 'group' + str(rank))

        # Flush the buffers
        self.h5file.flush()

        self._reopen()

        group = self.h5file.root
        if common.verbose:
            print()
            print("Rank array reading progress: ")
        # Get the metadata on the previosly saved arrays
        for rank in range(minrank, maxrank + 1):
            # Create an array for later comparison
            a = np.ones((1,) * rank, 'i')
            # Get the actual array
            b = group.array.read()
            if common.verbose:
                print("%3d," % (rank), end=' ')
            if not a.tolist() == b.tolist() and common.verbose:
                dset = group.array
                print("Info from dataset:", dset._v_pathname)
                print("  Shape: ==>", dset.shape, end=' ')
                print("  typecode ==> %c" % dset.typecode)
                print("Array b read from file. Shape: ==>", b.shape, end=' ')
                print(". Type ==> %c" % b.dtype.char)
            self.assertEqual(a.shape, b.shape)
            if a.dtype.char == "i":
                # Special expection. We have no way to distinguish between
                # "l" and "i" typecode, and we can consider them the same
                # to all practical effects
                self.assertTrue(b.dtype.char == "l" or b.dtype.char == "i")
            else:
                self.assertEqual(a.dtype.char, b.dtype.char)

            self.assertEqual(a, b)

            # Iterate over the next group
            group = self.h5file.get_node(group, 'group' + str(rank))

        if common.verbose:
            print()  # This flush the stdout buffer


# Test Record class
class Record(tables.IsDescription):
    var1 = StringCol(itemsize=4, dflt=b"abcd", pos=0)
    var2 = StringCol(itemsize=1, dflt=b"a", pos=1)
    var3 = BoolCol(dflt=1)
    var4 = Int8Col(dflt=1)
    var5 = UInt8Col(dflt=1)
    var6 = Int16Col(dflt=1)
    var7 = UInt16Col(dflt=1)
    var8 = Int32Col(dflt=1)
    var9 = UInt32Col(dflt=1)
    var10 = Int64Col(dflt=1)
    var11 = Float32Col(dflt=1.0)
    var12 = Float64Col(dflt=1.0)
    var13 = ComplexCol(itemsize=8, dflt=(1.+0.j))
    var14 = ComplexCol(itemsize=16, dflt=(1.+0.j))
    if hasattr(tables, 'Float16Col'):
        var15 = tables.Float16Col(dflt=1.0)
    if hasattr(tables, 'Float96Col'):
        var16 = tables.Float96Col(dflt=1.0)
    if hasattr(tables, 'Float128Col'):
        var17 = tables.Float128Col(dflt=1.0)
    if hasattr(tables, 'Complex196Col'):
        var18 = tables.ComplexCol(itemsize=24, dflt=(1.+0.j))
    if hasattr(tables, 'Complex256Col'):
        var19 = tables.ComplexCol(itemsize=32, dflt=(1.+0.j))


class TableReadTestCase(common.TempFileMixin, TestCase):
    nrows = 100

    def setUp(self):
        super(TableReadTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        table = self.h5file.create_table(self.h5file.root, 'table', Record)
        for i in range(self.nrows):
            table.row.append()  # Fill 100 rows with default values

        self._reopen(mode='a')

    def test01_readTableChar(self):
        """Checking column conversion into NumPy in read().

        Char flavor

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        for colname in table.colnames:
            numcol = table.read(field=colname)
            typecol = table.coltypes[colname]
            itemsizecol = table.description._v_dtypes[colname].base.itemsize
            nctypecode = numcol.dtype.char
            if typecol == "string":
                if itemsizecol > 1:
                    orignumcol = np.array(['abcd']*self.nrows, dtype='S4')
                else:
                    orignumcol = np.array(['a']*self.nrows, dtype='S1')
                if common.verbose:
                    print("Typecode of NumPy column read:", nctypecode)
                    print("Should look like:", 'c')
                    print("Itemsize of column:", itemsizecol)
                    print("Shape of NumPy column read:", numcol.shape)
                    print("Should look like:", orignumcol.shape)
                    print("First 3 elements of read col:", numcol[:3])
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test01_readTableNum(self):
        """Checking column conversion into NumPy in read().

        NumPy flavor

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        for colname in table.colnames:
            numcol = table.read(field=colname)
            typecol = table.coltypes[colname]
            nctypecode = np.typeNA[numcol.dtype.char[0]]
            if typecol != "string":
                if common.verbose:
                    print("Typecode of NumPy column read:", nctypecode)
                    print("Should look like:", typecol)
                orignumcol = np.ones(shape=self.nrows, dtype=numcol.dtype.char)
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test02_readCoordsChar(self):
        """Column conversion into NumPy in readCoords().

        Chars

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        coords = [1, 2, 3]
        self.nrows = len(coords)
        for colname in table.colnames:
            numcol = table.read_coordinates(coords, field=colname)
            typecol = table.coltypes[colname]
            itemsizecol = table.description._v_dtypes[colname].base.itemsize
            nctypecode = numcol.dtype.char
            if typecol == "string":
                if itemsizecol > 1:
                    orignumcol = np.array(['abcd']*self.nrows, dtype='S4')
                else:
                    orignumcol = np.array(['a']*self.nrows, dtype='S1')
                if common.verbose:
                    print("Typecode of NumPy column read:", nctypecode)
                    print("Should look like:", 'c')
                    print("Itemsize of column:", itemsizecol)
                    print("Shape of NumPy column read:", numcol.shape)
                    print("Should look like:", orignumcol.shape)
                    print("First 3 elements of read col:", numcol[:3])
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test02_readCoordsNum(self):
        """Column conversion into NumPy in read_coordinates().

        NumPy.

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        coords = [1, 2, 3]
        self.nrows = len(coords)
        for colname in table.colnames:
            numcol = table.read_coordinates(coords, field=colname)
            typecol = table.coltypes[colname]
            type_ = numcol.dtype.type
            if typecol != "string":
                if typecol == "int64":
                    return
                if common.verbose:
                    print("Type of read NumPy column:", type_)
                    print("Should look like:", typecol)
                orignumcol = np.ones(shape=self.nrows, dtype=numcol.dtype.char)
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test03_getIndexNumPy(self):
        """Getting table rows specifyied as NumPy scalar integers."""

        table = self.h5file.root.table
        coords = np.array([1, 2, 3], dtype='int8')
        for colname in table.colnames:
            numcol = [table[coord][colname] for coord in coords]
            typecol = table.coltypes[colname]
            if typecol != "string":
                if typecol == "int64":
                    return
                numcol = np.array(numcol, typecol)
                if common.verbose:
                    type_ = numcol.dtype.type
                    print("Type of read NumPy column:", type_)
                    print("Should look like:", typecol)
                orignumcol = np.ones(shape=len(numcol),
                                     dtype=numcol.dtype.char)
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test04_setIndexNumPy(self):
        """Setting table rows specifyied as NumPy integers."""

        self._reopen(mode='a')
        table = self.h5file.root.table
        table.flavor = "numpy"
        coords = np.array([1, 2, 3], dtype='int8')
        # Modify row 1
        # From PyTables 2.0 on, assignments to records can be done
        # only as tuples (see http://projects.scipy.org/scipy/numpy/ticket/315)
        # table[coords[0]] = ["aasa","x"]+[232]*12

        n = len(Record.columns) - 2

        table[coords[0]] = tuple(["aasa", "x"]+[232]*n)     # XXX
        # record = list(table[coords[0]])
        record = table.read(coords[0], coords[0] + 1)
        if common.verbose:
            print("Original row:\n"
                  "['aasa', 'x', True, -24, 232, 232, 232, 232, 232L, "
                  "232, 232.0, 232.0, (232 + 0j), (232+0j), 232.0, "
                  "(232+0j)]\n")
            print("Read row:\n", record)
        self.assertEqual(record['var1'], b'aasa')
        self.assertEqual(record['var2'], b'x')
        self.assertEqual(record['var3'], True)
        self.assertEqual(record['var4'], -24)
        self.assertEqual(record['var7'], 232)


# The declaration of the nested table:
class Info(tables.IsDescription):
    _v_pos = 3
    Name = StringCol(itemsize=2)
    Value = ComplexCol(itemsize=16)


class TestTDescr(tables.IsDescription):

    """A description that has several nested columns."""

    x = Int32Col(dflt=0, shape=2, pos=0)  # 0
    y = FloatCol(dflt=1, shape=(2, 2))
    z = UInt8Col(dflt=1)
    z3 = EnumCol({'r': 4, 'g': 2, 'b': 1}, 'r', 'int32', shape=2)
    color = StringCol(itemsize=4, dflt=b"ab", pos=2)
    info = Info()

    class Info(tables.IsDescription):  # 1
        _v_pos = 1
        name = StringCol(itemsize=2)
        value = ComplexCol(itemsize=16, pos=0)  # 0
        y2 = FloatCol(pos=1)  # 1
        z2 = UInt8Col()

        class Info2(tables.IsDescription):
            y3 = Time64Col(shape=2)
            name = StringCol(itemsize=2)
            value = ComplexCol(itemsize=16, shape=2)


class TableNativeFlavorTestCase(common.TempFileMixin, TestCase):
    nrows = 100

    def setUp(self):
        super(TableNativeFlavorTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        table = self.h5file.create_table(self.h5file.root, 'table', TestTDescr,
                                         expectedrows=self.nrows)
        table.flavor = "numpy"
        for i in range(self.nrows):
            table.row.append()  # Fill 100 rows with default values
        table.flush()

    def test01a_basicTableRead(self):
        """Checking the return of a NumPy in read()."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        data = table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the value of some columns
        # A flat column
        col = table.cols.x[:3]
        self.assertTrue(isinstance(col, np.ndarray))
        npcol = np.zeros((3, 2), dtype="int32")
        self.assertTrue(allequal(col, npcol, "numpy"))

        # A nested column
        col = table.cols.Info[:3]
        self.assertTrue(isinstance(col, np.ndarray))
        dtype = [('value', 'c16'),
                 ('y2', 'f8'),
                 ('Info2',
                  [('name', 'S2'),
                   ('value', 'c16', (2,)),
                   ('y3', 'f8', (2,))]),
                 ('name', 'S2'),
                 ('z2', 'u1')]
        npcol = np.zeros((3,), dtype=dtype)
        self.assertEqual(col.dtype.descr, npcol.dtype.descr)
        if common.verbose:
            print("col-->", col)
            print("npcol-->", npcol)

        # A copy() is needed in case the buffer can be in different segments
        self.assertEqual(bytes(col.copy().data), bytes(npcol.data))

    def test01b_basicTableRead(self):
        """Checking the return of a NumPy in read() (strided version)."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        data = table[::3]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the value of some columns
        # A flat column
        col = table.cols.x[:9:3]
        self.assertTrue(isinstance(col, np.ndarray))
        npcol = np.zeros((3, 2), dtype="int32")
        self.assertTrue(allequal(col, npcol, "numpy"))

        # A nested column
        col = table.cols.Info[:9:3]
        self.assertTrue(isinstance(col, np.ndarray))
        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npcol = np.zeros((3,), dtype=dtype)
        self.assertEqual(col.dtype.descr, npcol.dtype.descr)
        if common.verbose:
            print("col-->", col)
            print("npcol-->", npcol)

        # A copy() is needed in case the buffer can be in different segments
        self.assertEqual(bytes(col.copy().data), bytes(npcol.data))

    def test02_getWhereList(self):
        """Checking the return of NumPy in get_where_list method."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        data = table.get_where_list('z == 1')
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        self.assertTrue(allequal(data, np.arange(100, dtype="i8"), "numpy"))

    def test03a_readWhere(self):
        """Checking the return of NumPy in read_where method (strings)."""

        table = self.h5file.root.table
        table.cols.color.create_index()
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.read_where('color == b"ab"')
        if common.verbose:
            print("Type of read:", type(data))
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), self.nrows)

    def test03b_readWhere(self):
        """Checking the return of NumPy in read_where method (numeric)."""

        table = self.h5file.root.table
        table.cols.z.create_index()
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.read_where('z == 0')
        if common.verbose:
            print("Type of read:", type(data))
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 0)

    def test04a_createTable(self):
        """Checking the Table creation from a numpy recarray."""

        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npdata = np.zeros((3,), dtype=dtype)
        table = self.h5file.create_table(self.h5file.root, 'table2', npdata)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table2
        data = table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test04b_appendTable(self):
        """Checking appending a numpy recarray."""

        table = self.h5file.root.table
        npdata = table[3:6]
        table.append(npdata)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table[-3:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("Last 3 elements of read:", data[-3:])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test05a_assignColumn(self):
        """Checking assigning to a column."""

        table = self.h5file.root.table
        table.cols.z[:] = np.zeros((100,), dtype='u1')
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.z[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        self.assertTrue(allequal(data, np.zeros((100,), dtype="u1"), "numpy"))

    def test05b_modifyingColumns(self):
        """Checking modifying several columns at once."""

        table = self.h5file.root.table
        xcol = np.ones((3, 2), 'int32')
        ycol = np.zeros((3, 2, 2), 'float64')
        zcol = np.zeros((3,), 'uint8')
        table.modify_columns(3, 6, 1, [xcol, ycol, zcol], ['x', 'y', 'z'])
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(data.copy().data, ycol.data)

    def test05c_modifyingColumns(self):
        """Checking modifying several columns using a single numpy buffer."""

        table = self.h5file.root.table
        dtype = [('x', 'i4', (2,)), ('y', 'f8', (2, 2)), ('z', 'u1')]
        nparray = np.zeros((3,), dtype=dtype)
        table.modify_columns(3, 6, 1, nparray, ['x', 'y', 'z'])
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        ycol = np.zeros((3, 2, 2), 'float64')
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(data.copy().data, ycol.data)

    def test06a_assignNestedColumn(self):
        """Checking assigning a nested column (using modify_column)."""

        table = self.h5file.root.table
        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npdata = np.zeros((3,), dtype=dtype)
        data = table.cols.Info[3:6]
        table.modify_column(3, 6, 1, column=npdata, colname='Info')
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.Info[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test06b_assignNestedColumn(self):
        """Checking assigning a nested column (using the .cols accessor)."""

        table = self.h5file.root.table
        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npdata = np.zeros((3,), dtype=dtype)
        #self.assertRaises(NotImplementedError,
        #                  table.cols.Info.__setitem__, slice(3,6,1),  npdata)
        table.cols.Info[3:6] = npdata
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.Info[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test07a_modifyingRows(self):
        """Checking modifying several rows at once (using modify_rows)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[0:3]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.modify_rows(3, 6, 1, rows=chunk)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        ycol = np.zeros((3, 2, 2), 'float64')-1
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test07b_modifyingRows(self):
        """Checking modifying several rows at once (using cols accessor)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[0:3]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.cols[3:6] = chunk
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table

        # Check that some column has been actually modified
        ycol = np.zeros((3, 2, 2), 'float64')-1
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test08a_modifyingRows(self):
        """Checking modifying just one row at once (using modify_rows)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[3:4]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.modify_rows(6, 7, 1, chunk)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table

        # Check that some column has been actually modified
        ycol = np.zeros((2, 2), 'float64')-1
        data = table.cols.y[6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test08b_modifyingRows(self):
        """Checking modifying just one row at once (using cols accessor)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[3:4]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.cols[6] = chunk
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table

        # Check that some column has been actually modified
        ycol = np.zeros((2, 2), 'float64')-1
        data = table.cols.y[6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test09a_getStrings(self):
        """Checking the return of string columns with spaces."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        rdata = table.get_where_list('color == b"ab"')
        data = table.read_coordinates(rdata)
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        for idata in data['color']:
            self.assertEqual(idata, np.array("ab", dtype="|S4"))

    def test09b_getStrings(self):
        """Checking the return of string columns with spaces.

        (modify)

        """

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        for i in range(50):
            table.cols.color[i] = "a  "
        table.flush()
        data = table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        for i in range(100):
            idata = data['color'][i]
            if i >= 50:
                self.assertEqual(idata, np.array("ab", dtype="|S4"))
            else:
                self.assertEqual(idata, np.array("a  ", dtype="|S4"))

    def test09c_getStrings(self):
        """Checking the return of string columns with spaces.

        (append)

        """

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        row = table.row
        for i in range(50):
            row["color"] = "a  "   # note the trailing spaces
            row.append()
        table.flush()
        if self.close:
            self.h5file.close()
            self.h5file = tables.open_file(self.h5fname, "a")
        data = self.h5file.root.table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 150)

        # Finally, check that the contents are ok
        for i in range(150):
            idata = data['color'][i]
            if i < 100:
                self.assertEqual(idata, np.array("ab", dtype="|S4"))
            else:
                self.assertEqual(idata, np.array("a  ", dtype="|S4"))


class TableNativeFlavorOpenTestCase(TableNativeFlavorTestCase):
    close = 0


class TableNativeFlavorCloseTestCase(TableNativeFlavorTestCase):
    close = 1


class AttributesTestCase(common.TempFileMixin, TestCase):
    def setUp(self):
        super(AttributesTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        self.h5file.create_group(self.h5file.root, 'group')

    def test01_writeAttribute(self):
        """Checking the creation of a numpy attribute."""

        group = self.h5file.root.group
        g_attrs = group._v_attrs
        g_attrs.numpy1 = np.zeros((1, 1), dtype='int16')
        if self.close:
            self._reopen(mode='a')
            group = self.h5file.root.group
            g_attrs = group._v_attrs

        # Check that we can retrieve a numpy object
        data = g_attrs.numpy1
        npcomp = np.zeros((1, 1), dtype='int16')

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npcomp.dtype.descr)
        if common.verbose:
            print("npcomp-->", npcomp)
            print("data-->", data)
        self.assertTrue(allequal(npcomp, data, "numpy"))

    def test02_updateAttribute(self):
        """Checking the modification of a numpy attribute."""

        group = self.h5file.root.group
        g_attrs = group._v_attrs
        g_attrs.numpy1 = np.zeros((1, 2), dtype='int16')
        if self.close:
            self._reopen(mode='a')
            group = self.h5file.root.group
            g_attrs = group._v_attrs

        # Update this attribute
        g_attrs.numpy1 = np.ones((1, 2), dtype='int16')

        # Check that we can retrieve a numpy object
        data = g_attrs.numpy1
        npcomp = np.ones((1, 2), dtype='int16')

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npcomp.dtype.descr)
        if common.verbose:
            print("npcomp-->", npcomp)
            print("data-->", data)
        self.assertTrue(allequal(npcomp, data, "numpy"))


class AttributesOpenTestCase(AttributesTestCase):
    close = 0


class AttributesCloseTestCase(AttributesTestCase):
    close = 1


class StrlenTestCase(common.TempFileMixin, TestCase):
    def setUp(self):
        super(StrlenTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        group = self.h5file.create_group(self.h5file.root, 'group')
        tablelayout = {'Text': StringCol(itemsize=1000), }
        self.table = self.h5file.create_table(group, 'table', tablelayout)
        self.table.flavor = 'numpy'
        row = self.table.row
        row['Text'] = 'Hello Francesc!'     # XXX: check unicode --> bytes
        row.append()
        row['Text'] = 'Hola Francesc!'      # XXX: check unicode --> bytes
        row.append()
        self.table.flush()

    def test01(self):
        """Checking the lengths of strings (read field)."""

        if self.close:
            self._reopen(mode='a')
            self.table = self.h5file.root.group.table

        # Get both strings
        str1 = self.table.col('Text')[0]
        str2 = self.table.col('Text')[1]
        if common.verbose:
            print("string1-->", str1)
            print("string2-->", str2)

        # Check that both NumPy objects are equal
        self.assertEqual(len(str1), len(b'Hello Francesc!'))
        self.assertEqual(len(str2), len(b'Hola Francesc!'))
        self.assertEqual(str1, b'Hello Francesc!')
        self.assertEqual(str2, b'Hola Francesc!')

    def test02(self):
        """Checking the lengths of strings (read recarray)."""

        if self.close:
            self._reopen(mode='a')
            self.table = self.h5file.root.group.table

        # Get both strings
        str1 = self.table[:]['Text'][0]
        str2 = self.table[:]['Text'][1]

        # Check that both NumPy objects are equal
        self.assertEqual(len(str1), len(b'Hello Francesc!'))
        self.assertEqual(len(str2), len(b'Hola Francesc!'))
        self.assertEqual(str1, b'Hello Francesc!')
        self.assertEqual(str2, b'Hola Francesc!')

    def test03(self):
        """Checking the lengths of strings (read recarray, row by row)."""

        if self.close:
            self._reopen(mode='a')
            self.table = self.h5file.root.group.table

        # Get both strings
        str1 = self.table[0]['Text']
        str2 = self.table[1]['Text']

        # Check that both NumPy objects are equal
        self.assertEqual(len(str1), len(b'Hello Francesc!'))
        self.assertEqual(len(str2), len(b'Hola Francesc!'))
        self.assertEqual(str1, b'Hello Francesc!')
        self.assertEqual(str2, b'Hola Francesc!')


class StrlenOpenTestCase(StrlenTestCase):
    close = 0


class StrlenCloseTestCase(StrlenTestCase):
    close = 1


def suite():
    theSuite = unittest.TestSuite()
    niter = 1

    # theSuite.addTest(unittest.makeSuite(StrlenOpenTestCase))
    # theSuite.addTest(unittest.makeSuite(Basic0DOneTestCase))
    # theSuite.addTest(unittest.makeSuite(GroupsArrayTestCase))
    for i in range(niter):
        theSuite.addTest(unittest.makeSuite(Basic0DOneTestCase))
        theSuite.addTest(unittest.makeSuite(Basic0DTwoTestCase))
        theSuite.addTest(unittest.makeSuite(Basic1DOneTestCase))
        theSuite.addTest(unittest.makeSuite(Basic1DTwoTestCase))
        theSuite.addTest(unittest.makeSuite(Basic1DThreeTestCase))
        theSuite.addTest(unittest.makeSuite(Basic2DTestCase))
        theSuite.addTest(unittest.makeSuite(GroupsArrayTestCase))
        theSuite.addTest(unittest.makeSuite(TableReadTestCase))
        theSuite.addTest(unittest.makeSuite(TableNativeFlavorOpenTestCase))
        theSuite.addTest(unittest.makeSuite(TableNativeFlavorCloseTestCase))
        theSuite.addTest(unittest.makeSuite(AttributesOpenTestCase))
        theSuite.addTest(unittest.makeSuite(AttributesCloseTestCase))
        theSuite.addTest(unittest.makeSuite(StrlenOpenTestCase))
        theSuite.addTest(unittest.makeSuite(StrlenCloseTestCase))
        if common.heavy:
            theSuite.addTest(unittest.makeSuite(Basic10DTestCase))
            # The 32 dimensions case takes forever to run!!
            # theSuite.addTest(unittest.makeSuite(Basic32DTestCase))
    return theSuite


if __name__ == '__main__':
    common.parse_argv(sys.argv)
    common.print_versions()
    unittest.main(defaultTest='suite')
