← Back to branch summary

~ubuntu-branches/ubuntu/natty/pytables/natty-updates

« back to all changes in this revision

Viewing changes to test/test_lists.py

  • Committer: Bazaar Package Importer
  • Author(s): Alexandre Fayolle
  • Date: 2006-06-28 10:45:03 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20060628104503-cc251q5o5j3e2k10
  * Fixed call to pyversions in debian/rules which failed on recent versions 
    of pyversions
  * Fixed clean rule in debian/rules which left the stamp files behind
  * Acknowledge NMU
  * Added Alexandre Fayolle to uploaders

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_lists.py
1
 
import sys
2
 
import unittest
3
 
import os
4
 
import tempfile
5
 
from tables import *
6
 
 
7
 
from test_all import verbose
8
 
 
9
 
# Check if we are using python 2.2
10
 
if sys.version_info[0] == 2 and sys.version_info[1] == 2:
11
 
    python22 = 1
12
 
else:
13
 
    python22 = 0
14
 
 
15
 
def WriteRead(testTuple):
16
 
    if verbose:
17
 
        print '\n', '-=' * 30
18
 
        print "Running test for object %s" % \
19
 
                  (type(testTuple))
20
 
 
21
 
    # Create an instance of HDF5 Table
22
 
    file = tempfile.mktemp(".h5")
23
 
    fileh = openFile(file, mode = "w")
24
 
    root = fileh.root
25
 
 
26
 
    # Create the array under root and name 'somearray'
27
 
    a = testTuple
28
 
    try:
29
 
        fileh.createArray(root, 'somearray', a, "Some array")
30
 
    except ValueError:
31
 
        fileh.close()
32
 
        os.remove(file)
33
 
        # re-raise ValueError exception
34
 
        raise ValueError
35
 
    # Close the file
36
 
    fileh.close()
37
 
 
38
 
    # Re-open the file in read-only mode
39
 
    fileh = openFile(file, mode = "r")
40
 
    root = fileh.root
41
 
 
42
 
    # Read the saved array
43
 
    b = root.somearray.read()
44
 
    # Compare them. They should be equal.
45
 
    if not a == b and verbose:
46
 
        print "Write and read lists/tuples differ!"
47
 
        print "Object written:", a
48
 
        print "Object read:", b
49
 
 
50
 
 
51
 
    # Check strictly the array equality
52
 
    assert a == b
53
 
 
54
 
    # Close the file
55
 
    fileh.close()
56
 
    # Then, delete the file
57
 
    os.remove(file)
58
 
    return file
59
 
    
60
 
class BasicTestCase(unittest.TestCase):
61
 
 
62
 
    def test00_char(self):
63
 
        "Data integrity during recovery (character types)"
64
 
 
65
 
        a = self.charList
66
 
        WriteRead(a)
67
 
        return
68
 
 
69
 
    def test01_types(self):
70
 
        "Data integrity during recovery (numerical types)"
71
 
        
72
 
        a = self.numericalList
73
 
        WriteRead(a)
74
 
        return
75
 
 
76
 
class Basic0DOneTestCase(BasicTestCase):
77
 
    # Scalar case
78
 
    title = "Rank-0 case 1"
79
 
    numericalList = 3
80
 
    charList = "3"
81
 
    
82
 
class Basic0DTwoTestCase(BasicTestCase):
83
 
    # Scalar case
84
 
    title = "Rank-0 case 2"
85
 
    numericalList = 33.34
86
 
    charList = "33"*500
87
 
    
88
 
# This does not work anymore because I've splitted the chunked arrays to happen
89
 
# mainly in EArray objects
90
 
# class Basic1DZeroTestCase(BasicTestCase):
91
 
#     title = "Rank-1 case 0"
92
 
#     numericalList = []
93
 
#     charList = []
94
 
 
95
 
class Basic1DOneTestCase(BasicTestCase):
96
 
    # 1D case
97
 
    title = "Rank-1 case 1"
98
 
    numericalList = [3]
99
 
    charList = ["a"]
100
 
    
101
 
class Basic1DTwoTestCase(BasicTestCase):
102
 
    # 1D case
103
 
    title = "Rank-1 case 2"
104
 
    numericalList = [3.2, 4.2]
105
 
    charList = ["aaa"]
106
 
    
107
 
class Basic1DThreeTestCase(BasicTestCase):
108
 
    # 1D case
109
 
    # Detection for tuples (only works for 0-dimensional tuples)
110
 
    # i.e. it won't work with ((23,2)) or [(23,2)]
111
 
    title = "Rank-1 case 3"
112
 
    numericalList = (3, 4, 5.2)
113
 
    charList = ("aaa", "bbb")
114
 
    
115
 
class Basic2DTestCase(BasicTestCase):
116
 
    # 2D case
117
 
    title = "Rank-2 case 1"
118
 
    numericalList = [[1,2]]*5
119
 
    charList = [["qq","zz"]]*5
120
 
    
121
 
class Basic10DTestCase(BasicTestCase):
122
 
    # 10D case
123
 
    title = "Rank-10 case 1"
124
 
    numericalList = [[[[[[[[[[1,2],[3,4]]]]]]]]]]*5
125
 
    # Dimensions greather than 6 in strings gives some warnings
126
 
    charList = [[[[[[[[[["a","b"],["qq","zz"]]]]]]]]]]*5
127
 
    
128
 
 
129
 
class ExceptionTestCase(unittest.TestCase):
130
 
 
131
 
    def test00_char(self):
132
 
        "Non suppported lists objects (character objects)"
133
 
 
134
 
        if verbose:
135
 
            print '\n', '-=' * 30
136
 
            print "Running test for %s" % \
137
 
                  (self.title)
138
 
        a = self.charList
139
 
        try:
140
 
            WriteRead(a)
141
 
        except ValueError:
142
 
            if verbose:
143
 
                (type, value, traceback) = sys.exc_info()
144
 
                print "\nGreat!, the next error was catched!"
145
 
                print type, ":", value
146
 
        else:
147
 
            self.fail("expected an ValueError")
148
 
            
149
 
 
150
 
        return
151
 
 
152
 
    def test01_types(self): 
153
 
        "Non supported lists object (numerical types)"
154
 
        
155
 
        a = self.numericalList
156
 
        try:
157
 
            WriteRead(a)
158
 
        except ValueError:
159
 
            # Close the file
160
 
            #fileh.close()
161
 
            # Then, delete the file
162
 
            #os.remove(file)
163
 
            if verbose:
164
 
                (type, value, traceback) = sys.exc_info()
165
 
                print "\nGreat!, the next ValueError was catched!"
166
 
                print value
167
 
        else:
168
 
            self.fail("expected an ValueError")
169
 
            
170
 
        return
171
 
 
172
 
 
173
 
class Basic1DFourTestCase(ExceptionTestCase):
174
 
    # numeric is still not able to detect that
175
 
    # Activate when numarray support this kind of detection
176
 
    title = "Rank-1 case 4 (non-regular list)"
177
 
    numericalList = [3, [4, 5.2]]
178
 
    charList = ["aaa", ["bbb", "ccc"]]
179
 
    
180
 
 
181
 
class GetItemTestCase(unittest.TestCase):
182
 
 
183
 
    def test00_single(self):
184
 
        "Single element access (character types)"
185
 
        
186
 
        file = tempfile.mktemp(".h5")
187
 
        fileh = openFile(file, mode = "w")
188
 
        # Create the array under root and name 'somearray'
189
 
        a = self.charList
190
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
191
 
 
192
 
        # Get and compare an element
193
 
        if verbose:
194
 
            print "Original first element:", a[0]
195
 
            print "Read first element:", arr[0]
196
 
        assert a[0] == arr[0]
197
 
        
198
 
        # Close the file
199
 
        fileh.close()
200
 
        # Then, delete the file
201
 
        os.remove(file)
202
 
        return
203
 
 
204
 
    def test01_single(self):
205
 
        "Single element access (numerical types)"
206
 
        
207
 
        file = tempfile.mktemp(".h5")
208
 
        fileh = openFile(file, mode = "w")
209
 
        # Create the array under root and name 'somearray'
210
 
        a = self.numericalList
211
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
212
 
 
213
 
        # Get and compare an element
214
 
        if verbose:
215
 
            print "Original first element:", a[0]
216
 
            print "Read first element:", arr[0]
217
 
        assert a[0] == arr[0]
218
 
        
219
 
        # Close the file
220
 
        fileh.close()
221
 
        # Then, delete the file
222
 
        os.remove(file)
223
 
        return
224
 
 
225
 
    def test02_range(self):
226
 
        "Range element access (character types)"
227
 
        
228
 
        file = tempfile.mktemp(".h5")
229
 
        fileh = openFile(file, mode = "w")
230
 
        # Create the array under root and name 'somearray'
231
 
        a = self.charListME
232
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
233
 
 
234
 
        # Get and compare an element
235
 
        if verbose:
236
 
            print "Original elements:", a[1:4]
237
 
            print "Read elements:", arr[1:4]
238
 
        assert a[1:4] == arr[1:4]
239
 
        
240
 
        # Close the file
241
 
        fileh.close()
242
 
        # Then, delete the file
243
 
        os.remove(file)
244
 
        return
245
 
 
246
 
    def test03_range(self):
247
 
        "Range element access (numerical types)"
248
 
        
249
 
        file = tempfile.mktemp(".h5")
250
 
        fileh = openFile(file, mode = "w")
251
 
        # Create the array under root and name 'somearray'
252
 
        a = self.numericalListME
253
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
254
 
 
255
 
        # Get and compare an element
256
 
        if verbose:
257
 
            print "Original elements:", a[1:4]
258
 
            print "Read elements:", arr[1:4]
259
 
        assert a[1:4] == arr[1:4]
260
 
        
261
 
        # Close the file
262
 
        fileh.close()
263
 
        # Then, delete the file
264
 
        os.remove(file)
265
 
        return
266
 
 
267
 
    def test04_range(self):
268
 
        "Range element access, strided (character types)"
269
 
        global python22
270
 
 
271
 
        file = tempfile.mktemp(".h5")
272
 
        fileh = openFile(file, mode = "w")
273
 
        # Create the array under root and name 'somearray'
274
 
        a = self.charListME
275
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
276
 
 
277
 
        # Extended slicing not supported in Python 2.2
278
 
        if not python22:
279
 
            # Get and compare an element
280
 
            if verbose:
281
 
                print "Original elements:", a[1:4:2]
282
 
                print "Read elements:", arr[1:4:2]
283
 
            assert a[1:4:2] == arr[1:4:2]
284
 
        
285
 
        # Close the file
286
 
        fileh.close()
287
 
        # Then, delete the file
288
 
        os.remove(file)
289
 
        return
290
 
 
291
 
    def test05_range(self):
292
 
        "Range element access (numerical types)"
293
 
        global python22
294
 
 
295
 
        file = tempfile.mktemp(".h5")
296
 
        fileh = openFile(file, mode = "w")
297
 
        # Create the array under root and name 'somearray'
298
 
        a = self.numericalListME
299
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
300
 
 
301
 
        # Extended slicing not supported in Python 2.2
302
 
        if not python22:
303
 
            # Get and compare an element
304
 
            if verbose:
305
 
                print "Original elements:", a[1:4:2]
306
 
                print "Read elements:", arr[1:4:2]
307
 
            assert a[1:4:2] == arr[1:4:2]
308
 
                
309
 
        # Close the file
310
 
        fileh.close()
311
 
        # Then, delete the file
312
 
        os.remove(file)
313
 
        return
314
 
 
315
 
    def test06_negativeIndex(self):
316
 
        "Negative Index element access (character types)"
317
 
        
318
 
        file = tempfile.mktemp(".h5")
319
 
        fileh = openFile(file, mode = "w")
320
 
        # Create the array under root and name 'somearray'
321
 
        a = self.charListME
322
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
323
 
 
324
 
        # Get and compare an element
325
 
        if verbose:
326
 
            print "Original last element:", a[-1]
327
 
            print "Read last element:", arr[-1]
328
 
        assert a[-1] == arr[-1]
329
 
        
330
 
        # Close the file
331
 
        fileh.close()
332
 
        # Then, delete the file
333
 
        os.remove(file)
334
 
        return
335
 
 
336
 
    def test07_negativeIndex(self):
337
 
        "Negative Index element access (numerical types)"
338
 
        
339
 
        file = tempfile.mktemp(".h5")
340
 
        fileh = openFile(file, mode = "w")
341
 
        # Create the array under root and name 'somearray'
342
 
        a = self.numericalListME
343
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
344
 
 
345
 
        # Get and compare an element
346
 
        if verbose:
347
 
            print "Original before last element:", a[-2]
348
 
            print "Read before last element:", arr[-2]
349
 
        assert a[-2] == arr[-2]
350
 
        
351
 
        # Close the file
352
 
        fileh.close()
353
 
        # Then, delete the file
354
 
        os.remove(file)
355
 
        return
356
 
 
357
 
    def test08_negativeRange(self):
358
 
        "Negative range element access (character types)"
359
 
        
360
 
        file = tempfile.mktemp(".h5")
361
 
        fileh = openFile(file, mode = "w")
362
 
        # Create the array under root and name 'somearray'
363
 
        a = self.charListME
364
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
365
 
 
366
 
        # Get and compare an element
367
 
        if verbose:
368
 
            print "Original last elements:", a[-4:-1]
369
 
            print "Read last elements:", arr[-4:-1]
370
 
        assert a[-4:-1] == arr[-4:-1]
371
 
        
372
 
        # Close the file
373
 
        fileh.close()
374
 
        # Then, delete the file
375
 
        os.remove(file)
376
 
        return
377
 
 
378
 
    def test09_negativeRange(self):
379
 
        "Negative range element access (numerical types)"
380
 
        
381
 
        file = tempfile.mktemp(".h5")
382
 
        fileh = openFile(file, mode = "w")
383
 
        # Create the array under root and name 'somearray'
384
 
        a = self.numericalListME
385
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
386
 
 
387
 
        # Get and compare an element
388
 
        if verbose:
389
 
            print "Original last elements:", a[-4:-1]
390
 
            print "Read last elements:", arr[-4:-1]
391
 
        assert a[-4:-1] == arr[-4:-1]
392
 
        
393
 
        # Close the file
394
 
        fileh.close()
395
 
        # Then, delete the file
396
 
        os.remove(file)
397
 
        return
398
 
 
399
 
class GI1ListTestCase(GetItemTestCase):
400
 
    title = "Rank-1 case 1 (lists)"
401
 
    numericalList = [3]
402
 
    numericalListME = [3,2,1,0,4,5,6]
403
 
    charList = ["3"]
404
 
    charListME = ["321","221","121","021","421","521","621"]
405
 
    
406
 
class GI1TupleTestCase(GetItemTestCase):
407
 
    title = "Rank-1 case 1 (tuples)"
408
 
    numericalList = (3,)
409
 
    numericalListME = (3,2,1,0,4,5,6)
410
 
    charList = ("3",)
411
 
    charListME = ("321","221","121","021","421","521","621")
412
 
    
413
 
class GI2ListTestCase(GetItemTestCase):
414
 
    # A more complex example
415
 
    title = "Rank-1,2 case 2 (lists)"
416
 
    numericalList = [3,4]
417
 
    numericalListME = [[3,2,1,0,4,5,6],
418
 
                       [2,1,0,4,5,6,7],
419
 
                       [4,3,2,1,0,4,5],
420
 
                       [3,2,1,0,4,5,6],
421
 
                       [3,2,1,0,4,5,6]]
422
 
    
423
 
    charList = ["a","b"]
424
 
    charListME = [["321","221","121","021","421","521","621"],
425
 
                  ["21","21","11","02","42","21","61"],
426
 
                  ["31","21","12","21","41","51","621"],
427
 
                  ["321","221","121","021","421","521","621"],
428
 
                  ["3241","2321","13216","0621","4421","5421","a621"],
429
 
                  ["a321","s221","d121","g021","b421","5vvv21","6zxzxs21"]]
430
 
    
431
 
class GI2TupleTestCase(GetItemTestCase):
432
 
    # A more complex example
433
 
    title = "Rank-1,2 case 2 (tuples)"
434
 
    numericalList = (3,4)
435
 
    numericalListME = ((3,2,1,0,4,5,6),
436
 
                       (2,1,0,4,5,6,7),
437
 
                       (4,3,2,1,0,4,5),
438
 
                       (3,2,1,0,4,5,6),
439
 
                       (3,2,1,0,4,5,6))
440
 
    
441
 
    charList = ("a","b")
442
 
    charListME = (("321","221","121","021","421","521","621"),
443
 
                  ("21","21","11","02","42","21","61"),
444
 
                  ("31","21","12","21","41","51","621"),
445
 
                  ("321","221","121","021","421","521","621"),
446
 
                  ("3241","2321","13216","0621","4421","5421","a621"),
447
 
                  ("a321","s221","d121","g021","b421","5vvv21","6zxzxs21"))
448
 
    
449
 
 
450
 
class GeneratorTestCase(unittest.TestCase):
451
 
 
452
 
    def test00a_single(self):
453
 
        "Testing generator access to Arrays, single elements (char)"
454
 
        
455
 
        file = tempfile.mktemp(".h5")
456
 
        fileh = openFile(file, mode = "w")
457
 
        # Create the array under root and name 'somearray'
458
 
        a = self.charList
459
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
460
 
 
461
 
        # Get and compare an element
462
 
        ga = [i for i in a]
463
 
        garr = [i for i in arr]
464
 
        if verbose:
465
 
            print "Result of original iterator:", ga
466
 
            print "Result of read generator:", garr
467
 
        assert ga == garr
468
 
        
469
 
        # Close the file
470
 
        fileh.close()
471
 
        # Then, delete the file
472
 
        os.remove(file)
473
 
        return
474
 
 
475
 
    def test00b_me(self):
476
 
        "Testing generator access to Arrays, multiple elements (char)"
477
 
        
478
 
        file = tempfile.mktemp(".h5")
479
 
        fileh = openFile(file, mode = "w")
480
 
        # Create the array under root and name 'somearray'
481
 
        a = self.charListME
482
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
483
 
 
484
 
        # Get and compare an element
485
 
        ga = [i for i in a]
486
 
        garr = [i for i in arr]
487
 
        if verbose:
488
 
            print "Result of original iterator:", ga
489
 
            print "Result of read generator:", garr
490
 
        assert ga == garr
491
 
        
492
 
        # Close the file
493
 
        fileh.close()
494
 
        # Then, delete the file
495
 
        os.remove(file)
496
 
        return
497
 
 
498
 
    def test01a_single(self):
499
 
        "Testing generator access to Arrays, single elements (numeric)"
500
 
        
501
 
        file = tempfile.mktemp(".h5")
502
 
        fileh = openFile(file, mode = "w")
503
 
        # Create the array under root and name 'somearray'
504
 
        a = self.numericalList
505
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
506
 
 
507
 
        # Get and compare an element
508
 
        ga = [i for i in a]
509
 
        garr = [i for i in arr]
510
 
        if verbose:
511
 
            print "Result of original iterator:", ga
512
 
            print "Result of read generator:", garr
513
 
        assert ga == garr
514
 
        
515
 
        # Close the file
516
 
        fileh.close()
517
 
        # Then, delete the file
518
 
        os.remove(file)
519
 
        return
520
 
 
521
 
    def test01b_me(self):
522
 
        "Testing generator access to Arrays, multiple elements (numeric)"
523
 
        
524
 
        file = tempfile.mktemp(".h5")
525
 
        fileh = openFile(file, mode = "w")
526
 
        # Create the array under root and name 'somearray'
527
 
        a = self.numericalListME
528
 
        arr=fileh.createArray(fileh.root, 'somearray', a, "Some array")
529
 
 
530
 
        # Get and compare an element
531
 
        ga = [i for i in a]
532
 
        garr = [i for i in arr]
533
 
        if verbose:
534
 
            print "Result of original iterator:", ga
535
 
            print "Result of read generator:", garr
536
 
        assert ga == garr
537
 
        
538
 
        # Close the file
539
 
        fileh.close()
540
 
        # Then, delete the file
541
 
        os.remove(file)
542
 
        return
543
 
 
544
 
class GE1ListTestCase(GeneratorTestCase):
545
 
    # Scalar case
546
 
    title = "Rank-1 case 1 (lists)"
547
 
    numericalList = [3]
548
 
    numericalListME = [3,2,1,0,4,5,6]
549
 
    charList = ["3"]
550
 
    charListME = ["321","221","121","021","421","521","621"]
551
 
    
552
 
class GE1TupleTestCase(GeneratorTestCase):
553
 
    # Scalar case
554
 
    title = "Rank-1 case 1 (tuples)"
555
 
    numericalList = (3,)
556
 
    numericalListME = (3,2,1,0,4,5,6)
557
 
    charList = ("3",)
558
 
    charListME = ("321","221","121","021","421","521","621")
559
 
    
560
 
class GE2ListTestCase(GeneratorTestCase):
561
 
    # Scalar case
562
 
    title = "Rank-1,2 case 2 (lists)"
563
 
    numericalList = [3,4]
564
 
    numericalListME = [[3,2,1,0,4,5,6],
565
 
                       [2,1,0,4,5,6,7],
566
 
                       [4,3,2,1,0,4,5],
567
 
                       [3,2,1,0,4,5,6],
568
 
                       [3,2,1,0,4,5,6]]
569
 
    
570
 
    charList = ["a","b"]
571
 
    charListME = [["321","221","121","021","421","521","621"],
572
 
                  ["21","21","11","02","42","21","61"],
573
 
                  ["31","21","12","21","41","51","621"],
574
 
                  ["321","221","121","021","421","521","621"],
575
 
                  ["3241","2321","13216","0621","4421","5421","a621"],
576
 
                  ["a321","s221","d121","g021","b421","5vvv21","6zxzxs21"]]
577
 
    
578
 
class GE2TupleTestCase(GeneratorTestCase):
579
 
    # Scalar case
580
 
    title = "Rank-1,2 case 2 (tuples)"
581
 
    numericalList = (3,4)
582
 
    numericalListME = ((3,2,1,0,4,5,6),
583
 
                       (2,1,0,4,5,6,7),
584
 
                       (4,3,2,1,0,4,5),
585
 
                       (3,2,1,0,4,5,6),
586
 
                       (3,2,1,0,4,5,6))
587
 
    
588
 
    charList = ("a","b")
589
 
    charListME = (("321","221","121","021","421","521","621"),
590
 
                  ("21","21","11","02","42","21","61"),
591
 
                  ("31","21","12","21","41","51","621"),
592
 
                  ("321","221","121","021","421","521","621"),
593
 
                  ("3241","2321","13216","0621","4421","5421","a621"),
594
 
                  ("a321","s221","d121","g021","b421","5vvv21","6zxzxs21"))
595
 
    
596
 
 
597
 
def suite():
598
 
    theSuite = unittest.TestSuite()
599
 
    niter = 1
600
 
 
601
 
    #theSuite.addTest(unittest.makeSuite(Basic1DFourTestCase))
602
 
    for i in range(niter):
603
 
        # The scalar case test should be refined in order to work
604
 
        theSuite.addTest(unittest.makeSuite(Basic0DOneTestCase))
605
 
        theSuite.addTest(unittest.makeSuite(Basic0DTwoTestCase))
606
 
        #theSuite.addTest(unittest.makeSuite(Basic1DZeroTestCase))
607
 
        theSuite.addTest(unittest.makeSuite(Basic1DOneTestCase))
608
 
        theSuite.addTest(unittest.makeSuite(Basic1DTwoTestCase))
609
 
        theSuite.addTest(unittest.makeSuite(Basic1DThreeTestCase))
610
 
        theSuite.addTest(unittest.makeSuite(Basic1DFourTestCase))
611
 
        theSuite.addTest(unittest.makeSuite(Basic2DTestCase))
612
 
        theSuite.addTest(unittest.makeSuite(Basic10DTestCase))
613
 
        theSuite.addTest(unittest.makeSuite(GI1ListTestCase))
614
 
        theSuite.addTest(unittest.makeSuite(GI1TupleTestCase))    
615
 
        theSuite.addTest(unittest.makeSuite(GI2ListTestCase))    
616
 
        theSuite.addTest(unittest.makeSuite(GI2TupleTestCase))    
617
 
        theSuite.addTest(unittest.makeSuite(GE1ListTestCase))
618
 
        theSuite.addTest(unittest.makeSuite(GE1TupleTestCase))
619
 
        theSuite.addTest(unittest.makeSuite(GE2ListTestCase))
620
 
        theSuite.addTest(unittest.makeSuite(GE2TupleTestCase))
621
 
 
622
 
    return theSuite
623
 
 
624
 
 
625
 
if __name__ == '__main__':
626
 
    unittest.main( defaultTest='suite' )