8
import numarray.records as records
9
from numarray import strings
11
from tables.hdf5Extension import getIndices
13
from test_all import verbose, heavy, allequal
14
# If we use the test_all.allequal function, a segmentation violation appears
15
# but only when the test runs *alone* and *without* verbose parameters!
16
# However, if we use the allequal in this module, everything seems to work well
17
# this should be further investigated!. F. Alted 2004/01/01
19
# Update: That seems to work well now. Perhaps a bug in numarray that
20
# has been solved? F. Alted 2004/08/06
23
# """Checks if two numarrays are equal"""
25
# if a.shape <> b.shape:
29
# if len(a.shape) == 0:
30
# if str(equal(a,b)) == '1':
34
# # Multidimensional case
36
# for i in range(len(a.shape)):
37
# result = logical_and.reduce(result)
42
class Record(IsDescription):
43
var1 = StringCol(4, "abcd", shape=(2,2)) # 4-character string array
44
var2 = IntCol(((1,1),(1,1)), shape=(2,2)) # integer array
45
var3 = Int16Col(2) # short integer
46
var4 = FloatCol(3.1) # double (double-precision)
47
var5 = Float32Col(4.2) # float (single-precision)
48
var6 = UInt16Col(5) # unsigned short integer
49
var7 = StringCol(length=1, dflt="e") # 1-character String
51
# From 0.3 on, you can dynamically define the tables with a dictionary
52
RecordDescriptionDict = {
53
'var1': StringCol(length=4, shape=(2,2)), # 4-character String
54
'var2': IntCol(shape=(2,2)), # integer array
55
'var3': Int16Col(), # short integer
56
'var4': FloatCol(), # double (double-precision)
57
'var5': Float32Col(), # float (single-precision)
58
'var6': Int16Col(), # unsigned short integer
59
'var7': StringCol(length=1), # 1-character String
62
class BasicTestCase(unittest.TestCase):
65
title = "This is the table title"
69
complib = "zlib" # Default compression library
76
# Create an instance of an HDF5 Table
77
self.file = tempfile.mktemp(".h5")
78
self.fileh = openFile(self.file, self.mode)
79
self.rootgroup = self.fileh.root
83
def initRecArray(self):
84
record = self.recordtemplate
88
#for i in xrange(self.expectedrows+1):
89
for i in xrange(self.expectedrows+1):
91
# Both forms (list or chararray) works
92
var1 = [['%04d' % (self.expectedrows - i)] * 2] * 2
93
# var1 = strings.array([['%04d' % (self.expectedrows - i)] * 2] * 2,
94
# itemsize = 4, shape=(2,2))
96
var2 = ((i, 1), (1,1)) # *-*
98
var3 = i % self.maxshort
100
if isinstance(row.field('var4'), NumArray):
101
tmplist.append([float(i), float(i*i)])
103
tmplist.append(float(i))
104
if isinstance(row.field('var5'), NumArray):
105
tmplist.append(array((float(i),)*4))
107
tmplist.append(float(i))
108
# var6 will be like var3 but byteswaped
109
tmplist.append(((var3>>8) & 0xff) + ((var3<<8) & 0xff00))
110
var7 = var1[0][0][-1]
112
buflist.append(tmplist)
114
self.record=records.array(buflist, formats=record._formats,
116
shape = self.expectedrows)
120
def populateFile(self):
121
group = self.rootgroup
122
if self.recarrayinit:
123
# Initialize an starting buffer, if any
127
filters = Filters(complevel = self.compress,
128
complib = self.complib)
129
table = self.fileh.createTable(group, 'table'+str(j), self.record,
132
expectedrows = self.expectedrows)
133
if not self.recarrayinit:
134
# Get the row object associated with the new table
138
for i in xrange(self.expectedrows):
139
row['var1'] = '%04d' % (self.expectedrows - i)
140
row['var7'] = row['var1'][0][0][-1]
141
row['var2'] = ((i, 1), (1,1)) # *-*
142
row['var3'] = i % self.maxshort
143
if isinstance(row['var4'], NumArray):
144
row['var4'] = [float(i), float(i*i)]
146
row['var4'] = float(i)
147
if isinstance(row['var5'], NumArray):
148
row['var5'] = array((float(i),)*4)
150
row['var5'] = float(i)
151
# var6 will be like var3 but byteswaped
152
row['var6'] = ((row['var3']>>8) & 0xff) + \
153
((row['var3']<<8) & 0xff00)
154
#print("Saving -->", row)
157
# Flush the buffer for this table
159
# Create a new group (descendant of group)
160
group2 = self.fileh.createGroup(group, 'group'+str(j))
161
# Iterate over this new group (group2)
167
#del self.fileh, self.rootgroup
170
#----------------------------------------
172
def test01_readTable(self):
173
"""Checking table read and cuts"""
175
rootgroup = self.rootgroup
177
print '\n', '-=' * 30
178
print "Running %s.test01_readTable..." % self.__class__.__name__
180
# Create an instance of an HDF5 Table
181
self.fileh = openFile(self.file, "r")
182
table = self.fileh.getNode("/table0")
184
# Choose a small value for buffer size
185
table._v_maxTuples = 3
186
# Read the records and select those with "var2" file less than 20
187
result = [ rec['var2'][0][0] for rec in table.iterrows()
188
if rec['var2'][0][0] < 20 ]
190
print "Table:", repr(table)
191
print "Nrows in", table._v_pathname, ":", table.nrows
192
print "Last record in table ==>", rec
193
print "Total selected records in table ==> ", len(result)
194
nrows = self.expectedrows - 1
195
assert (rec['var1'][0][0], rec['var2'][0][0], rec['var7']) == \
197
if isinstance(rec['var5'], NumArray):
198
assert allequal(rec['var5'], array((float(nrows),)*4, Float32))
200
assert rec['var5'] == float(nrows)
201
assert len(result) == 20
203
def test01b_readTable(self):
204
"""Checking table read and cuts (multidimensional columns case)"""
206
rootgroup = self.rootgroup
208
print '\n', '-=' * 30
209
print "Running %s.test01b_readTable..." % self.__class__.__name__
211
# Create an instance of an HDF5 Table
212
self.fileh = openFile(self.file, "r")
213
table = self.fileh.getNode("/table0")
215
# Choose a small value for buffer size
216
table._v_maxTuples = 3
217
# Read the records and select those with "var2" file less than 20
218
result = [ rec['var5'] for rec in table.iterrows()
219
if rec['var2'][0][0] < 20 ]
221
print "Nrows in", table._v_pathname, ":", table.nrows
222
print "Last record in table ==>", rec
223
print "Total selected records in table ==> ", len(result)
224
nrows = table.row.nrow()
225
if isinstance(rec['var5'], NumArray):
226
assert allequal(result[0], array((float(0),)*4, Float32))
227
assert allequal(result[1], array((float(1),)*4, Float32))
228
assert allequal(result[2], array((float(2),)*4, Float32))
229
assert allequal(result[3], array((float(3),)*4, Float32))
230
assert allequal(result[10], array((float(10),)*4, Float32))
231
assert allequal(rec['var5'], array((float(nrows),)*4, Float32))
233
assert rec['var5'] == float(nrows)
234
assert len(result) == 20
236
# Read the records and select those with "var2" file less than 20
237
result = [ rec['var1'] for rec in table.iterrows()
238
if rec['var2'][0][0] < 20 ]
240
if isinstance(rec['var1'], strings.CharArray):
241
a = strings.array([['%04d' % (self.expectedrows - 0)]*2]*2)
242
assert allequal(result[0], a)
243
a = strings.array([['%04d' % (self.expectedrows - 1)]*2]*2)
244
assert allequal(result[1], a)
245
a = strings.array([['%04d' % (self.expectedrows - 2)]*2]*2)
246
assert allequal(result[2], a)
247
a = strings.array([['%04d' % (self.expectedrows - 3)]*2]*2)
248
assert allequal(result[3], a)
249
a = strings.array([['%04d' % (self.expectedrows - 10)]*2]*2)
250
assert allequal(result[10], a)
251
a = strings.array([['%04d' % (1)]*2]*2)
252
assert allequal(rec['var1'], a)
254
assert rec['var1'] == "0001"
255
assert len(result) == 20
257
def test02_AppendRows(self):
258
"""Checking whether appending record rows works or not"""
260
# Now, open it, but in "append" mode
261
self.fileh = openFile(self.file, mode = "a")
262
self.rootgroup = self.fileh.root
264
print '\n', '-=' * 30
265
print "Running %s.test02_AppendRows..." % self.__class__.__name__
268
table = self.fileh.getNode("/group0/table1")
269
# Get their row object
272
print "Nrows in old", table._v_pathname, ":", table.nrows
273
print "Record Format ==>", table._v_fmt
274
print "Record Size ==>", table.rowsize
276
for i in xrange(self.appendrows):
277
row['var1'] = '%04d' % (self.appendrows - i)
278
row['var7'] = row['var1'][0][0][-1]
279
row['var2'] = ((i, 1), (1,1)) # *-*
280
row['var3'] = i % self.maxshort
281
if isinstance(row['var4'], NumArray):
282
row['var4'] = [float(i), float(i*i)]
284
row['var4'] = float(i)
285
if isinstance(row['var5'], NumArray):
286
row['var5'] = array((float(i),)*4)
288
row['var5'] = float(i)
291
# Flush the buffer for this table and read it
293
result = [ row['var2'][0][0] for row in table.iterrows()
294
if row['var2'][0][0] < 20 ]
296
nrows = self.appendrows - 1
297
assert (row['var1'][0][0], row['var2'][0][0], row['var7']) == \
299
if isinstance(row['var5'], NumArray):
300
assert allequal(row['var5'], array((float(nrows),)*4, Float32))
302
assert row['var5'] == float(nrows)
303
if self.appendrows <= 20:
304
add = self.appendrows
307
assert len(result) == 20 + add # because we appended new rows
310
# CAVEAT: The next test only works for tables with rows < 2**15
311
def test03_endianess(self):
312
"""Checking if table is endianess aware"""
314
rootgroup = self.rootgroup
316
print '\n', '-=' * 30
317
print "Running %s.test03_endianess..." % self.__class__.__name__
319
# Create an instance of an HDF5 Table
320
self.fileh = openFile(self.file, "r")
321
table = self.fileh.getNode("/table0")
323
# Manually change the byteorder property for this table
324
table.byteorder = {"little":"big","big":"little"}[table.byteorder]
325
#table.togglebyteorder()
327
# Read the records and select the ones with "var6" column less than 20
328
result = [ rec['var2'] for rec in table.iterrows() if rec['var6'] < 20]
330
print "Nrows in", table._v_pathname, ":", table.nrows
331
print "Last record in table ==>", rec
332
print "Total selected records in table ==>", len(result)
333
nrows = self.expectedrows - 1
334
assert (rec['var1'][0][0], rec['var6']) == ("0001", nrows)
335
assert len(result) == 20
337
class BasicWriteTestCase(BasicTestCase):
341
class DictWriteTestCase(BasicTestCase):
342
# This checks also unidimensional arrays as columns
344
record = RecordDescriptionDict
346
maxTuples = 3 # Choose a small value for the buffer size
351
class RecArrayOneWriteTestCase(BasicTestCase):
352
title = "RecArrayOneWrite"
353
record=records.array(formats="(2,2)a4,(2,2)i4,i2,2f8,f4,i2,a1",
354
names='var1,var2,var3,var4,var5,var6,var7')
356
class RecArrayTwoWriteTestCase(BasicTestCase):
357
title = "RecArrayTwoWrite"
360
recordtemplate=records.array(formats="(2,2)a4,(2,2)i4,i2,f8,f4,i2,a1",
361
names='var1,var2,var3,var4,var5,var6,var7',
364
class RecArrayThreeWriteTestCase(BasicTestCase):
365
title = "RecArrayThreeWrite"
368
recordtemplate=records.array(formats="(2,2)a4,(2,2)i4,i2,2f8,4f4,i2,a1",
369
names='var1,var2,var3,var4,var5,var6,var7',
372
class CompressLZOTablesTestCase(BasicTestCase):
373
title = "CompressLZOTables"
377
class CompressUCLTablesTestCase(BasicTestCase):
378
title = "CompressUCLTables"
382
class CompressZLIBTablesTestCase(BasicTestCase):
383
title = "CompressOneTables"
387
class CompressTwoTablesTestCase(BasicTestCase):
388
title = "CompressTwoTables"
390
# This checks also unidimensional arrays as columns
391
record = RecordDescriptionDict
393
class BigTablesTestCase(BasicTestCase):
395
# 10000 rows takes much more time than we can afford for tests
396
# reducing to 1000 would be more than enough
397
# F. Alted 2004-01-19
398
# expectedrows = 10000
403
class BasicRangeTestCase(unittest.TestCase):
406
title = "This is the table title"
413
maxTuples = 3 # Choose a small value for the buffer size
420
# Create an instance of an HDF5 Table
421
self.file = tempfile.mktemp(".h5")
422
self.fileh = openFile(self.file, self.mode)
423
self.rootgroup = self.fileh.root
427
def populateFile(self):
428
group = self.rootgroup
431
table = self.fileh.createTable(group, 'table'+str(j), self.record,
433
filters = Filters(self.compress),
434
expectedrows = self.expectedrows)
435
# Get the row object associated with the new table
439
for i in xrange(self.expectedrows):
440
row['var1'] = '%04d' % (self.expectedrows - i)
441
row['var7'] = row['var1'][0][0][-1]
443
row['var3'] = i % self.maxshort
444
if isinstance(row['var4'], NumArray):
445
row['var4'] = [float(i), float(i*i)]
447
row['var4'] = float(i)
448
if isinstance(row['var5'], NumArray):
449
row['var5'] = array((float(i),)*4)
451
row['var5'] = float(i)
452
# var6 will be like var3 but byteswaped
453
row['var6'] = ((row['var3'] >> 8) & 0xff) + \
454
((row['var3'] << 8) & 0xff00)
457
# Flush the buffer for this table
459
# Create a new group (descendant of group)
460
group2 = self.fileh.createGroup(group, 'group'+str(j))
461
# Iterate over this new group (group2)
466
if self.fileh.isopen:
468
#del self.fileh, self.rootgroup
471
#----------------------------------------
473
def check_range(self):
475
rootgroup = self.rootgroup
476
# Create an instance of an HDF5 Table
477
self.fileh = openFile(self.file, "r")
478
table = self.fileh.getNode("/table0")
480
table._v_maxTuples = self.maxTuples
481
r = slice(self.start, self.stop, self.step)
482
#resrange = r.indices(table.nrows)
483
resrange = getIndices(r,table.nrows)
484
reslength = len(range(*resrange))
485
if self.checkrecarray:
486
recarray = table.read(self.start, self.stop, self.step)
488
for nrec in range(len(recarray)):
489
if recarray.field('var2')[nrec][0][0] < self.nrows:
490
result.append(recarray.field('var2')[nrec][0][0])
491
elif self.checkgetCol:
492
column = table.read(self.start, self.stop, self.step, 'var2')
494
for nrec in range(len(column)):
495
if column[nrec][0][0] < self.nrows: #*-*
496
result.append(column[nrec][0][0]) #*-*
498
result = [ rec['var2'][0][0] for rec in
499
table.iterrows(self.start, self.stop, self.step)
500
if rec['var2'][0][0] < self.nrows ]
503
startr = self.expectedrows + self.start
507
if self.stop == None:
510
stopr = self.expectedrows + self.stop
514
if self.nrows < stopr:
518
print "Nrows in", table._v_pathname, ":", table.nrows
520
if self.checkrecarray:
521
print "Last record *read* in recarray ==>", recarray[-1]
522
elif self.checkgetCol:
523
print "Last value *read* in getCol ==>", column[-1]
525
print "Last record *read* in table range ==>", rec
526
print "Total number of selected records ==>", len(result)
527
print "Selected records:\n", result
528
print "Selected records should look like:\n", \
529
range(startr, stopr, self.step)
530
print "start, stop, step ==>", startr, stopr, self.step
532
assert result == range(startr, stopr, self.step)
533
if startr < stopr and not (self.checkrecarray or self.checkgetCol):
534
if self.nrows < self.expectedrows:
535
assert rec['var2'][0][0] == \
536
range(self.start, self.stop, self.step)[-1]
538
assert rec['var2'][0][0] == range(startr, stopr, self.step)[-1]
543
def test01_range(self):
544
"""Checking ranges in table iterators (case1)"""
547
print '\n', '-=' * 30
548
print "Running %s.test01_range..." % self.__class__.__name__
550
# Case where step < maxTuples < 2*step
554
self.stop = self.expectedrows
559
def test02_range(self):
560
"""Checking ranges in table iterators (case2)"""
563
print '\n', '-=' * 30
564
print "Running %s.test02_range..." % self.__class__.__name__
566
# Case where step < maxTuples < 10*step
570
self.stop = self.expectedrows
575
def test03_range(self):
576
"""Checking ranges in table iterators (case3)"""
579
print '\n', '-=' * 30
580
print "Running %s.test03_range..." % self.__class__.__name__
582
# Case where step < maxTuples < 1.1*step
583
self.nrows = self.expectedrows
584
self.maxTuples = 11 # Choose a small value for the buffer size
586
self.stop = self.expectedrows
591
def test04_range(self):
592
"""Checking ranges in table iterators (case4)"""
595
print '\n', '-=' * 30
596
print "Running %s.test04_range..." % self.__class__.__name__
598
# Case where step == maxTuples
599
self.nrows = self.expectedrows
600
self.maxTuples = 11 # Choose a small value for the buffer size
602
self.stop = self.expectedrows
607
def test05_range(self):
608
"""Checking ranges in table iterators (case5)"""
611
print '\n', '-=' * 30
612
print "Running %s.test05_range..." % self.__class__.__name__
614
# Case where step > 1.1*maxTuples
616
self.maxTuples = 10 # Choose a small value for the buffer size
618
self.stop = self.expectedrows
623
def test06_range(self):
624
"""Checking ranges in table iterators (case6)"""
627
print '\n', '-=' * 30
628
print "Running %s.test06_range..." % self.__class__.__name__
630
# Case where step > 3*maxTuples
632
self.maxTuples = 3 # Choose a small value for the buffer size
634
self.stop = self.expectedrows
639
def test07_range(self):
640
"""Checking ranges in table iterators (case7)"""
643
print '\n', '-=' * 30
644
print "Running %s.test07_range..." % self.__class__.__name__
646
# Case where start == stop
648
self.maxTuples = 3 # Choose a small value for the buffer size
649
self.start = self.nrows
650
self.stop = self.nrows
655
def test08_range(self):
656
"""Checking ranges in table iterators (case8)"""
659
print '\n', '-=' * 30
660
print "Running %s.test08_range..." % self.__class__.__name__
662
# Case where start > stop
664
self.maxTuples = 3 # Choose a small value for the buffer size
665
self.start = self.nrows + 1
666
self.stop = self.nrows
671
def test09_range(self):
672
"""Checking ranges in table iterators (case9)"""
675
print '\n', '-=' * 30
676
print "Running %s.test09_range..." % self.__class__.__name__
678
# Case where stop = None
680
self.maxTuples = 3 # Choose a small value for the buffer size
687
def test10_range(self):
688
"""Checking ranges in table iterators (case10)"""
691
print '\n', '-=' * 30
692
print "Running %s.test10_range..." % self.__class__.__name__
694
# Case where start < 0 and stop = 0
695
self.nrows = self.expectedrows
696
self.maxTuples = 5 # Choose a small value for the buffer size
698
self.startr = self.expectedrows + self.start
700
self.stopr = self.expectedrows + self.stop
705
def test11_range(self):
706
"""Checking ranges in table iterators (case11)"""
709
print '\n', '-=' * 30
710
print "Running %s.test11_range..." % self.__class__.__name__
712
# Case where start < 0 and stop < 0
713
self.nrows = self.expectedrows
714
self.maxTuples = 5 # Choose a small value for the buffer size
716
self.startr = self.expectedrows + self.start
718
self.stopr = self.expectedrows + self.stop
723
def test12_range(self):
724
"""Checking ranges in table iterators (case12)"""
727
print '\n', '-=' * 30
728
print "Running %s.test12_range..." % self.__class__.__name__
730
# Case where start < 0 and stop < 0 and start > stop
731
self.nrows = self.expectedrows
732
self.maxTuples = 5 # Choose a small value for the buffer size
734
self.startr = self.expectedrows + self.start
736
self.stopr = self.expectedrows + self.stop
741
def test13_range(self):
742
"""Checking ranges in table iterators (case13)"""
745
print '\n', '-=' * 30
746
print "Running %s.test13_range..." % self.__class__.__name__
748
# Case where step < 0
754
(type, value, traceback) = sys.exc_info()
755
print "\nGreat!, the next ValueError was catched!"
760
self.fail("expected a ValueError")
762
# Case where step == 0
768
(type, value, traceback) = sys.exc_info()
769
print "\nGreat!, the next ValueError was catched!"
774
self.fail("expected a ValueError")
777
class IterRangeTestCase(BasicRangeTestCase):
780
class RecArrayRangeTestCase(BasicRangeTestCase):
783
class getColRangeTestCase(BasicRangeTestCase):
786
def test01_nonexistentField(self):
787
"""Checking non-existing Field in getCol method """
790
print '\n', '-=' * 30
791
print "Running %s.test01_nonexistentField..." % self.__class__.__name__
793
# Create an instance of an HDF5 Table
794
self.fileh = openFile(self.file, "r")
795
self.root = self.fileh.root
796
table = self.fileh.getNode("/table0")
799
column = table.read(field='non-existent-column')
802
(type, value, traceback) = sys.exc_info()
803
print "\nGreat!, the next LookupError was catched!"
808
self.fail("expected a LookupError")
811
class RecArrayIO(unittest.TestCase):
814
"Checking saving a normal recarray"
815
file = tempfile.mktemp(".h5")
816
fileh = openFile(file, "w")
819
intlist1 = [[456,23]*3]*2
820
intlist2 = array([[2,2]*3]*2)
821
arrlist1 = [['dbe']*2]*3
822
#arrlist2 = strings.array([['de']*2]*3)
823
arrlist2 = [['de']*2]*3
824
floatlist1 = [[1.2,2.3]*3]*4
825
floatlist2 = array([[4.5,2.4]*3]*4)
826
b = [[intlist1, arrlist1, floatlist1],[intlist2, arrlist2, floatlist2]]
827
r=records.array(b, names='col1,col2,col3')
829
# Save it in a table:
830
fileh.createTable(fileh.root, 'recarray', r)
833
r2 = fileh.root.recarray.read()
835
assert r.tostring() == r2.tostring()
841
"Checking saving a recarray with an offset in its buffer"
842
file = tempfile.mktemp(".h5")
843
fileh = openFile(file, "w")
846
intlist1 = [[456,23]*3]*2
847
intlist2 = array([[2,2]*3]*2)
848
arrlist1 = [['dbe']*2]*3
849
#arrlist2 = strings.array([['de']*2]*3)
850
arrlist2 = [['de']*2]*3
851
floatlist1 = [[1.2,2.3]*3]*4
852
floatlist2 = array([[4.5,2.4]*3]*4)
853
b = [[intlist1, arrlist1, floatlist1],[intlist2, arrlist2, floatlist2]]
854
r=records.array(b, names='col1,col2,col3')
856
# Get an offsetted bytearray
858
assert r1._byteoffset > 0
860
# Save it in a table:
861
fileh.createTable(fileh.root, 'recarray', r1)
864
r2 = fileh.root.recarray.read()
866
assert r1.tostring() == r2.tostring()
872
"Checking saving a large recarray with an offset in its buffer"
873
file = tempfile.mktemp(".h5")
874
fileh = openFile(file, "w")
877
intlist1 = [[[23,24,35]*6]*6]
878
intlist2 = array([[[2,3,4]*6]*6])
879
arrlist1 = [['dbe']*2]*3
880
#arrlist2 = strings.array([['de']*2]*3)
881
arrlist2 = [['de']*2]*3
882
floatlist1 = [[1.2,2.3]*3]*4
883
floatlist2 = array([[4.5,2.4]*3]*4)
884
b=[[intlist1, arrlist1, floatlist1],[intlist2, arrlist2, floatlist2]]
885
r=records.array(b*300, names='col1,col2,col3')
887
# Get an offsetted recarray
890
print "\noffseted recarray --> ", r1
891
assert r1._byteoffset > 0
893
# Save it in a table:
894
fileh.createTable(fileh.root, 'recarray', r1)
897
r2 = fileh.root.recarray.read()
899
assert r1.tostring() == r2.tostring()
905
"Checking saving a strided recarray with an offset in its buffer"
906
file = tempfile.mktemp(".h5")
907
fileh = openFile(file, "w")
910
intlist1 = [[[23,24,35]*6]*6]
911
intlist2 = array([[[2,3,4]*6]*6])
912
arrlist1 = [['dbe']*2]*3
913
#arrlist2 = strings.array([['de']*2]*3)
914
arrlist2 = [['de']*2]*3
915
floatlist1 = [[1.2,2.3]*3]*4
916
floatlist2 = array([[4.5,2.4]*3]*4)
917
b = [[intlist1, arrlist1, floatlist1],[intlist2, arrlist2, floatlist2]]
918
r=records.array(b*300, names='col1,col2,col3', shape=300)
920
# Get an strided recarray
923
# Get an offsetted bytearray
926
print "\noffseted and strided recarray --> ", r1
927
assert r1._byteoffset > 0
928
# Save it in a table:
929
fileh.createTable(fileh.root, 'recarray', r1)
932
r2 = fileh.root.recarray.read()
934
assert r1.tostring() == r2.tostring()
940
class DefaultValues(unittest.TestCase):
943
"Checking saving a Table MD with default values"
944
file = tempfile.mktemp(".h5")
945
#file = "/tmp/test.h5"
946
fileh = openFile(file, "w")
949
table = fileh.createTable(fileh.root, 'table', Record)
951
# Take a number of records a bit greater
952
nrows = int(table._v_maxTuples * 1.1)
953
# Fill the table with nrows records
954
for i in xrange(nrows):
956
table.row['var2'] = ((2,2),(2,2)) #*-*
957
# This injects the row values.
960
# We need to flush the buffers in table in order to get an
961
# accurate number of records on it.
964
# Create a recarray with the same default values
965
buffer = [[[["abcd"]*2]*2, ((1,1),(1,1)), 2, 3.1, 4.2, 5, "e"]]
966
r=records.array(buffer*nrows,
967
formats='(2,2)a4,(2,2)i4,i2,f8,f4,i2,a1') #*-*
969
# Assign the value exceptions
970
r.field("c2")[3] = ((2,2), (2,2)) #*-*
971
r.field("c2")[4] = ((2,2), (2,2)) #*-*
973
# Read the table in another recarray
976
# This generates too much output. Activate only when
977
# self._v_maxTuples is very small (<10)
979
print "Table values:"
980
for row in table.iterrows():
983
print "Record values:"
986
assert r.tostring() == r2.tostring()
992
#----------------------------------------------------------------------
995
theSuite = unittest.TestSuite()
997
#heavy = 1 # Uncomment this only for testing purposes
999
#theSuite.addTest(unittest.makeSuite(CompressUCLTablesTestCase))
1000
#theSuite.addTest(unittest.makeSuite(BasicWriteTestCase))
1001
#theSuite.addTest(unittest.makeSuite(RecArrayOneWriteTestCase))
1002
#theSuite.addTest(unittest.makeSuite(RecArrayTwoWriteTestCase))
1003
#theSuite.addTest(unittest.makeSuite(RecArrayThreeWriteTestCase))
1004
#theSuite.addTest(unittest.makeSuite(DefaultValues))
1005
#theSuite.addTest(unittest.makeSuite(RecArrayIO))
1006
#theSuite.addTest(unittest.makeSuite(BigTablesTestCase))
1008
for n in range(niter):
1009
theSuite.addTest(unittest.makeSuite(BasicWriteTestCase))
1010
theSuite.addTest(unittest.makeSuite(DictWriteTestCase))
1011
theSuite.addTest(unittest.makeSuite(RecArrayOneWriteTestCase))
1012
theSuite.addTest(unittest.makeSuite(RecArrayTwoWriteTestCase))
1013
theSuite.addTest(unittest.makeSuite(RecArrayThreeWriteTestCase))
1014
theSuite.addTest(unittest.makeSuite(CompressLZOTablesTestCase))
1015
theSuite.addTest(unittest.makeSuite(CompressUCLTablesTestCase))
1016
theSuite.addTest(unittest.makeSuite(CompressZLIBTablesTestCase))
1017
theSuite.addTest(unittest.makeSuite(CompressTwoTablesTestCase))
1018
theSuite.addTest(unittest.makeSuite(IterRangeTestCase))
1019
theSuite.addTest(unittest.makeSuite(RecArrayRangeTestCase))
1020
theSuite.addTest(unittest.makeSuite(getColRangeTestCase))
1021
theSuite.addTest(unittest.makeSuite(DefaultValues))
1022
theSuite.addTest(unittest.makeSuite(RecArrayIO))
1024
theSuite.addTest(unittest.makeSuite(BigTablesTestCase))
1029
if __name__ == '__main__':
1030
unittest.main( defaultTest='suite' )
added
removed
test/test_tablesMD.py
