source: branches/numpy/anuga/load_mesh/test_loadASCII.py @ 7242

Last change on this file since 7242 was 7035, checked in by rwilson, 16 years ago

Back-merge from Numeric trunk.
File size: 20.3 KB
RevLine 
[2253]1#!/usr/bin/env python
2
3import tempfile
4import unittest
5import os
6import tempfile
7from os.path import splitext
8
[6304]9import numpy as num
[6360]10
[4165]11from anuga.load_mesh.loadASCII import *
[3514]12from anuga.coordinate_transforms.geo_reference import Geo_reference
[2253]13import loadASCII
14
[6304]15
[2253]16class loadASCIITestCase(unittest.TestCase):
17    def setUp(self):
[6360]18        self.dict = {}
[2253]19        self.dict['outline_segments'] = [(0, 1), (1, 2), (0, 2), (0, 3)]
20        self.dict['outline_segment_tags'] = ['50', '40', '30', '20']
21        self.dict['holes'] = [(0.2, 0.6)]
[6360]22        self.dict['point_attributes'] = [[5, 2], [4, 2], [3, 2], [2, 2]]
23        self.dict['regions'] = [(0.3, 0.3), (0.3, 0.4)]
[2253]24        self.dict['region_tags'] = ['1.3', 'yeah']
[6304]25        self.dict['region_max_areas'] = [36.0, -7.1]
[2253]26        self.dict['points'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0), (1.0, 1.0)]
[6360]27        self.dict['vertices'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0),
28                                 (1.0, 1.0), (2.0, 2.0)]
29        self.dict['triangles'] = [(3, 2, 4), (1, 0, 3), (3, 4,1), (2, 3, 0)]
30        self.dict['segments'] = [(0, 1), (1, 4), (2, 0), (0, 3), (4, 2)]
31        self.dict['triangle_tags'] = ['1.3', '1.3', '1.3', '1.3']
32        self.dict['vertex_attributes'] = [[1.2, 2.], [1.2, 2.], [1.2, 2.],
33                                          [1.2, 2.], [1.2, 3.]]
[2253]34        self.dict['triangle_neighbors'] = [[-1, 2, 3], [3, 2, -1],
35                                           [-1, 1, 0], [1, -1, 0]]
36        self.dict['segment_tags'] = ['50', '40', '30', '20', '40']
37        self.dict['vertex_attribute_titles'] = ['bed elevation', 'height']
[6304]38        self.dict['geo_reference'] = Geo_reference(56, 1.9, 1.9)
[6360]39
40        self.sparse_dict = {}
[2253]41        self.sparse_dict['outline_segments'] = []
42        self.sparse_dict['outline_segment_tags'] = []
43        self.sparse_dict['holes'] = []
[6304]44        self.sparse_dict['points'] = [(0.0, 0.0), (9, 8)]
45        self.sparse_dict['point_attributes'] = [[], []] # points don't have to
46                                                        # have attributes
[2253]47        self.sparse_dict['regions'] = []
48        self.sparse_dict['region_tags'] = []
49        self.sparse_dict['region_max_areas'] = []
50
51        self.sparse_dict['vertices'] = []
52        self.sparse_dict['triangles'] = []
53        self.sparse_dict['segments'] = []
54        self.sparse_dict['triangle_tags'] = []
55        self.sparse_dict['vertex_attributes'] = []
56        self.sparse_dict['triangle_neighbors'] = []
57        self.sparse_dict['segment_tags'] = []
58        self.sparse_dict['vertex_attribute_titles'] = []
[6360]59
60        self.blank_dict = {}
[2253]61        self.blank_dict['outline_segments'] = []
62        self.blank_dict['outline_segment_tags'] = []
63        self.blank_dict['holes'] = []
64        self.blank_dict['points'] = []
[6360]65        self.blank_dict['point_attributes'] = []
[2253]66        self.blank_dict['regions'] = []
67        self.blank_dict['region_tags'] = []
68        self.blank_dict['region_max_areas'] = []
69        self.blank_dict['vertices'] = []
70        self.blank_dict['triangles'] = []
71        self.blank_dict['segments'] = []
72        self.blank_dict['triangle_tags'] = []
73        self.blank_dict['vertex_attributes'] = []
74        self.blank_dict['triangle_neighbors'] = []
75        self.blank_dict['segment_tags'] = []
76        self.blank_dict['vertex_attribute_titles'] = []
[6360]77
78        self.tri_dict = {}
[6304]79        self.tri_dict['outline_segments'] = [[0, 1]]
[2253]80        self.tri_dict['outline_segment_tags'] = ['']
81        self.tri_dict['holes'] = []
[6304]82        self.tri_dict['points'] = [(9, 8), (7, 8)]
[6360]83        self.tri_dict['point_attributes'] = [[], []]
[2253]84        self.tri_dict['regions'] = []
85        self.tri_dict['region_tags'] = []
86        self.tri_dict['region_max_areas'] = []
[6304]87        self.tri_dict['vertices'] = [[9, 8], [7, 8], [4, 5]]
88        self.tri_dict['triangles'] = [[0, 1, 2]]
89        self.tri_dict['segments'] = [[0, 1]]
[2253]90        self.tri_dict['triangle_tags'] = ['']
[4902]91        self.tri_dict['vertex_attributes'] = None
[6304]92        self.tri_dict['triangle_neighbors'] = [[0, 0, 0]]
[2253]93        self.tri_dict['segment_tags'] = ['']
94        self.tri_dict['vertex_attribute_titles'] = []
[6360]95
96        self.seg_dict = {}
[6304]97        self.seg_dict['outline_segments'] = [[0, 1]]
[2253]98        self.seg_dict['outline_segment_tags'] = ['']
99        self.seg_dict['holes'] = []
[6304]100        self.seg_dict['points'] = [(9, 8), (7, 8)]
[6360]101        self.seg_dict['point_attributes'] = [[], []]
[6304]102        self.seg_dict['regions'] = [(5, 4)]
[6360]103        self.seg_dict['region_tags'] = ['']
[2253]104        self.seg_dict['region_max_areas'] = [-999]
[6304]105        self.seg_dict['vertices'] = [(9, 8), (7, 8)]
[2253]106        self.seg_dict['triangles'] = []
[6304]107        self.seg_dict['segments'] = [[0, 1]]
[2253]108        self.seg_dict['triangle_tags'] = []
[4902]109        self.seg_dict['vertex_attributes'] = None
[2253]110        self.seg_dict['triangle_neighbors'] = []
111        self.seg_dict['segment_tags'] = ['']
112        self.seg_dict['vertex_attribute_titles'] = []
[6360]113
114        self.reg_dict = {}
[6304]115        self.reg_dict['outline_segments'] = [[0, 1]]
[2253]116        self.reg_dict['outline_segment_tags'] = ['']
117        self.reg_dict['holes'] = []
[6304]118        self.reg_dict['points'] = [(9, 8), (7, 8)]
[6360]119        self.reg_dict['point_attributes'] = [[], []]
[6304]120        self.reg_dict['regions'] = [(5, 4)]
[2253]121        self.reg_dict['region_tags'] = ['']
122        self.reg_dict['region_max_areas'] = []
[6304]123        self.reg_dict['vertices'] = [(9, 8), (7, 8)]
[2253]124        self.reg_dict['triangles'] = []
[6304]125        self.reg_dict['segments'] = [[0, 1]]
[2253]126        self.reg_dict['triangle_tags'] = []
[6304]127        self.reg_dict['vertex_attributes'] = [[], []]
[2253]128        self.reg_dict['triangle_neighbors'] = []
129        self.reg_dict['segment_tags'] = ['']
130        self.reg_dict['vertex_attribute_titles'] = []
[6360]131
132        self.triangle_tags_dict = {}
[6304]133        self.triangle_tags_dict['outline_segments'] = [(0, 1), (1, 2),
134                                                       (0, 2), (0, 3)]
135        self.triangle_tags_dict['outline_segment_tags'] = ['50', '40',
136                                                           '30', '20']
[2253]137        self.triangle_tags_dict['holes'] = [(0.2, 0.6)]
[6304]138        self.triangle_tags_dict['point_attributes'] = [[5, 2], [4, 2],
139                                                       [3, 2], [2,2]]
[6360]140        self.triangle_tags_dict['regions'] = [(0.3, 0.3), (0.3, 0.4)]
[2253]141        self.triangle_tags_dict['region_tags'] = ['1.3', 'yeah']
[6304]142        self.triangle_tags_dict['region_max_areas'] = [36.0, -7.1]
143        self.triangle_tags_dict['points'] = [(0.0, 0.0), (0.0, 4.0),
144                                             (4.0, 0.0), (1.0, 1.0)]
[2253]145        self.triangle_tags_dict['vertices'] = [(0.0, 0.0), (0.0, 4.0),
[6304]146                                               (4.0, 0.0), (1.0, 1.0),
147                                               (2.0, 2.0)]
[2253]148        self.triangle_tags_dict['triangles'] = [(3, 2, 4), (1, 0, 3),
[6360]149                                                (3, 4, 1), (2, 3, 0)]
[2253]150        self.triangle_tags_dict['segments'] = [(0, 1), (1, 4), (2, 0),
[6304]151                                               (0, 3), (4, 2)]
152        self.triangle_tags_dict['triangle_tags'] = ['yeah', '1.3', '1.3', '']
[2253]153        self.triangle_tags_dict['vertex_attributes'] = [[1.2,2.], [1.2,2.],
[6304]154                                                        [1.2,2.], [1.2,2.],
155                                                        [1.2,3.]]
[2253]156        self.triangle_tags_dict['triangle_neighbors'] = [[-1, 2, 3], [3, 2, -1],
[6304]157                                                         [-1, 1, 0], [1, -1, 0]]
[2253]158        self.triangle_tags_dict['segment_tags'] = ['50', '40', '30', '20', '40']
[6304]159        self.triangle_tags_dict['vertex_attribute_titles'] = ['bed elevation',
160                                                              'height']
161        self.triangle_tags_dict['geo_reference'] = Geo_reference(56, 1.9, 1.9)
[6360]162
[2253]163    def tearDown(self):
164        pass
165
[6360]166  ############### .TSH ##########
[2253]167    def test_export_mesh_file(self):
168        meshDict = self.dict
[6304]169        fileName = tempfile.mktemp('.tsh')
[2253]170        export_mesh_file(fileName, meshDict)
171        loadedDict = import_mesh_file(fileName)
[6360]172
[6304]173        self.failUnless(num.alltrue(num.array(meshDict['vertices']) ==
[6154]174                                    num.array(loadedDict['vertices'])),
175                        'test_export_mesh_file failed. Test 1')
[6304]176        self.failUnless(num.alltrue(num.array(meshDict['triangles']) ==
[6154]177                                    num.array(loadedDict['triangles'])),
178                        'test_export_mesh_file failed. Test 2')
[6304]179        self.failUnless(num.alltrue(num.array(meshDict['segments']) ==
[6154]180                                    num.array(loadedDict['segments'])),
181                        'test_export_mesh_file failed. Test 3')
[6304]182        self.failUnless(num.alltrue(num.array(meshDict['triangle_tags']) ==
[6154]183                                    num.array(loadedDict['triangle_tags'])),
184                        'test_export_mesh_file failed. Test 4')
[5875]185
[6304]186        self.failUnless(meshDict['vertex_attributes'] ==
[2253]187                        loadedDict['vertex_attributes'],
[6154]188                        'test_export_mesh_file failed. Test 5')
[6304]189        self.failUnless(num.alltrue(num.array(meshDict['triangle_neighbors']) ==
[6154]190                                    num.array(loadedDict['triangle_neighbors'])),
191                        'test_export_mesh_file failed. Test 6')
[6304]192        self.failUnless(num.alltrue(num.array(meshDict['segment_tags']) ==
[6154]193                                    num.array(loadedDict['segment_tags'])),
194                        'test_export_mesh_file failed. Test 7')
[6304]195        self.failUnless(num.alltrue(num.array(meshDict['vertex_attribute_titles']) ==
[6154]196                                    num.array(loadedDict['vertex_attribute_titles'])),
197                        'test_export_mesh_file failed. Test 8')
[6304]198        self.failUnless(num.alltrue(num.array(meshDict['geo_reference']) ==
[6154]199                                    num.array(loadedDict['geo_reference'])),
200                        'test_export_mesh_file failed. Test 9')
[6360]201
[2253]202        os.remove(fileName)
[6360]203
[2253]204    def test_read_write_tsh_file(self):
205        dict = self.dict.copy()
[6304]206        fileName = tempfile.mktemp('.tsh')
207        export_mesh_file(fileName, dict)
[2253]208        loaded_dict = import_mesh_file(fileName)
209        os.remove(fileName)
210        dict = self.dict
[6428]211        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file')
[6360]212
[2253]213    def test_read_write_tsh_fileII(self):
214        dict = self.sparse_dict.copy()
[6304]215        fileName = tempfile.mktemp('.tsh')
216        export_mesh_file(fileName, dict)
[2253]217        loaded_dict = import_mesh_file(fileName)
[6360]218        dict = self.sparse_dict
219        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_fileII')
[2253]220        os.remove(fileName)
[6360]221
[2253]222    def test_read_write_tsh_fileIII(self):
223        dict = self.blank_dict.copy()
[6304]224        fileName = tempfile.mktemp('.tsh')
225        export_mesh_file(fileName, dict)
[2253]226        loaded_dict = import_mesh_file(fileName)
227        os.remove(fileName)
228        dict = self.blank_dict
[6428]229        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_fileIII')
[2253]230
231    def test_read_write_tsh_file4(self):
232        dict = self.seg_dict.copy()
[6304]233        fileName = tempfile.mktemp('.tsh')
234        export_mesh_file(fileName, dict)
[2253]235        loaded_dict = import_mesh_file(fileName)
236        os.remove(fileName)
[6360]237        dict = self.seg_dict
[6428]238        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file4')
[2253]239
240    def test_read_write_tsh_file5(self):
241        dict = self.triangle_tags_dict.copy()
[6304]242        fileName = tempfile.mktemp('.tsh')
243        export_mesh_file(fileName, dict)
[2253]244        loaded_dict = import_mesh_file(fileName)
245        dict = self.triangle_tags_dict
[6428]246        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file5')
[2253]247        os.remove(fileName)
248
249    def test_read_write_tsh_file6(self):
250        dict = self.tri_dict.copy()
[6304]251        fileName = tempfile.mktemp('.tsh')
252        export_mesh_file(fileName, dict)
[2253]253        loaded_dict = import_mesh_file(fileName)
[4899]254        dict = self.tri_dict
[6428]255        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file6')
[2253]256        os.remove(fileName)
[6360]257
[2253]258########################## BAD .TSH ##########################
259
260    def test_load_bad_no_file_tsh(self):
[6304]261        fileName = tempfile.mktemp('.tsh')
[7035]262        # use self.faileUnlessRaises(IOError, import_mesh_file(fileName))
[2253]263        try:
264            dict = import_mesh_file(fileName)
265        except IOError:
266            pass
267        else:
[6304]268            self.failUnless(0 == 1, 'imaginary file did not raise error!')
[6360]269
[2253]270    def test_read_write_tsh_file_bad(self):
271        dict = self.tri_dict.copy()
[6304]272        fileName = tempfile.mktemp('.xxx')
[2253]273        try:
[6304]274            export_mesh_file(fileName, dict)
[2253]275        except IOError:
276            pass
277        else:
[6360]278            self.failUnless(0 == 1, 'bad tsh file did not raise error!')
279
[2253]280    def test_import_tsh_bad(self):
[6304]281        fileName = tempfile.mktemp('.tsh')
282        file = open(fileName, 'w')
[2253]283        #   this is  a bad tsh file
[6304]284        file.write('elevn\n\
[2253]2851.0 what \n\
2860.0 the \n\
[6304]2871.0 !!! \n')
[2253]288        file.close()
289        try:
[4165]290            dict = import_mesh_file(fileName)
[2253]291        except IOError:
292            pass
293        else:
[6553]294            self.fail('bad tsh file did not raise error!')
[2253]295        os.remove(fileName)
296
297    def test_import_tsh3(self):
[6304]298        fileName = tempfile.mktemp('.tsh')
299        file = open(fileName, 'w')
300        file.write('1.0 \n\
[2253]301showme1.0 0.0 10.0 \n\
3020.0 1.0\n\
[6304]30313.0 \n')
[2253]304        file.close()
305        try:
[4165]306            dict = import_mesh_file(fileName)
[2253]307        except IOError:
308            pass
309        else:
[6553]310            self.fail('bad tsh file did not raise error!')
[6360]311        os.remove(fileName)
[2253]312
313  ############### .MSH ##########
[6360]314
[6428]315    def test_read_write_msh_file1(self):
[2253]316        dict = self.dict.copy()
[6304]317        fileName = tempfile.mktemp('.msh')
318        export_mesh_file(fileName, dict)
[2253]319        loaded_dict = loadASCII._read_msh_file(fileName)
320        os.remove(fileName)
321        dict = self.dict
[6428]322        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file1')
[2253]323
324    def test_read_write_msh_fileII(self):
325        dict = self.sparse_dict.copy()
[6304]326        fileName = tempfile.mktemp('.msh')
327        export_mesh_file(fileName, dict)
[2253]328        loaded_dict = loadASCII._read_msh_file(fileName)
329        os.remove(fileName)
330        dict = self.sparse_dict
[6304]331        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_fileII')
[6360]332
[2253]333    def test_read_write_msh_fileIII(self):
334        dict = self.blank_dict.copy()
[6304]335        fileName = tempfile.mktemp('.msh')
336        export_mesh_file(fileName, dict)
[2253]337        loaded_dict = loadASCII._read_msh_file(fileName)
338        os.remove(fileName)
339        dict = self.blank_dict
[6304]340        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_fileIII')
[6360]341
[2253]342    def test_read_write_msh_file4(self):
343        dict = self.seg_dict.copy()
[6304]344        fileName = tempfile.mktemp('.msh')
345        export_mesh_file(fileName, dict)
[2253]346        loaded_dict = loadASCII._read_msh_file(fileName)
347        os.remove(fileName)
348        dict = self.seg_dict
[6304]349        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file4')
[6360]350
[2253]351    def test_read_write_msh_file5(self):
352        dict = self.triangle_tags_dict.copy()
[6304]353        fileName = tempfile.mktemp('.msh')
354        export_mesh_file(fileName, dict)
[2253]355        loaded_dict = loadASCII._read_msh_file(fileName)
356        os.remove(fileName)
357        dict = self.triangle_tags_dict
[6304]358        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file5')
[6360]359
[2253]360    def test_read_write_msh_file6(self):
361        dict = self.tri_dict.copy()
[6304]362        fileName = tempfile.mktemp('.msh')
363        export_mesh_file(fileName, dict)
[2253]364        loaded_dict = loadASCII._read_msh_file(fileName)
365        os.remove(fileName)
366        dict = self.tri_dict
[6304]367        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file6')
[6360]368
[6304]369    def check_mesh_dicts(self, loaded_dict, dict, fail_string):
[6154]370        assert num.allclose(num.array(loaded_dict['points']),
371                            num.array(dict['points']))
[6304]372        assert num.allclose(num.array(loaded_dict['point_attributes']),
[6154]373                            num.array(dict['point_attributes']))
374        assert num.allclose(num.array(loaded_dict['outline_segments']),
375                            num.array(dict['outline_segments']))
[6360]376
[6304]377        self.failUnless(loaded_dict['outline_segment_tags'] ==
[2253]378                        dict['outline_segment_tags'],
379                        fail_string + ' failed!! Test 4')
[6360]380
[6154]381        assert num.allclose(num.array(loaded_dict['regions']),
382                            num.array(dict['regions']))
[6360]383
[6304]384        self.failUnless(loaded_dict['region_tags'] == dict['region_tags'],
[2253]385                        fail_string + ' failed!! Test 5')
[6360]386
[6154]387        assert num.allclose(num.array(loaded_dict['region_max_areas']),
388                            num.array(dict['region_max_areas']))
[6360]389
[6154]390        assert num.allclose(num.array(loaded_dict['holes']),
391                            num.array(dict['holes']))
[6360]392
[6154]393        assert num.allclose(num.array(dict['vertices']),
394                            num.array(loaded_dict['vertices']))
[6360]395
[6154]396        assert num.allclose(num.array(dict['triangles']),
397                            num.array(loaded_dict['triangles']))
[6360]398
[6154]399        assert num.allclose(num.array(dict['segments']),
400                            num.array(loaded_dict['segments']))
[6360]401        for ob, ldob in map(None, dict['triangle_tags'],
402                            loaded_dict['triangle_tags']):
[6428]403            msg = ('ob=\n%s\nshould be same as ldob=\n%s' % (str(ob), str(ldob)))
[5875]404            self.failUnless(ob == ldob,
[6428]405                            fail_string + ' failed\n' + msg)
[6304]406
[4902]407        # A bit hacky
[6428]408        self.failUnless(num.alltrue(loaded_dict['vertex_attributes'] ==
409                                    dict['vertex_attributes']) or
[6902]410                                    (loaded_dict['vertex_attributes'] ==
411                                    None and
412                                    dict['vertex_attributes'] == []),
[2253]413                        fail_string + ' failed!! Test vertex_attributes')
[6360]414
[6154]415        assert num.allclose(num.array(dict['triangle_neighbors']),
416                            num.array(loaded_dict['triangle_neighbors']))
[2253]417
[6360]418        for seg, ldseg in map(None, dict['segment_tags'],
[2253]419                              loaded_dict['segment_tags']):
[6428]420            msg = ('seg=\n"%s"\nshould be same as ldseg=\n"%s"'
421                   % (str(seg), str(ldseg)))
422            self.failUnless(seg == ldseg, fail_string + ' failed\n' + msg)
[6360]423
[2253]424        try:
[6904]425            assert num.allclose(num.array(dict['vertex_attribute_titles']),
426                                num.array(loaded_dict['vertex_attribute_titles']))
[6360]427        except IndexError:
[6904]428            self.failUnless(num.alltrue(num.array(loaded_dict['vertex_attribute_titles'])
429                            == num.array(dict['vertex_attribute_titles'])),
[6154]430                            fail_string + ' failed!! Test 8')
[6360]431
432        try:
[6428]433            msg = ("loaded_dict['geo_reference']=\n%s\n"
434                   "should be same as dict['geo_reference']=%s"
435                  % (str(loaded_dict['geo_reference']),
436                     str(dict['geo_reference'])))
[6304]437            self.failUnless(loaded_dict['geo_reference'] ==
438                            dict['geo_reference'],
[6428]439                            fail_string + ' failed\n' + msg)
[6360]440        except KeyError:        #??# 2 lines below??
[6428]441            msg = ("'dict' has no key 'geo_reference' "
442                   "but loaded_dict['geo_reference'] isn't None")
[6360]443            self.failUnless(not dict.has_key('geo_reference') and
444                                loaded_dict['geo_reference'] == None,
[6428]445                            fail_string + ' failed\n' + msg)
[2253]446
[6360]447########################## BAD .MSH ##########################
448
[2253]449    def test_load_bad_no_file_msh(self):
[6304]450        fileName = tempfile.mktemp('.msh')
[2253]451        try:
452            dict = import_mesh_file(fileName)
453        except IOError:
454            pass
455        else:
[6553]456            self.fail('imaginary file did not raise error!')
[6360]457
[4165]458    def throws_error_2_screen_test_import_mesh_bad(self):
[6304]459        fileName = tempfile.mktemp('.msh')
460        file = open(fileName, 'w')
461        # this is  a bad tsh file
462        file.write('elevn\n\
[2253]4631.0 what \n\
4640.0 the \n\
[6304]4651.0 !!! \n')
[2253]466        file.close()
467        try:
[4165]468            dict = import_mesh_file(fileName)
[2253]469        except IOError:
470            pass
471        else:
[6553]472            self.fail('bad msh file did not raise error!')
[6360]473        os.remove(fileName)
[6074]474
[6360]475################################################################################
476
[6304]477if __name__ == '__main__':
[2253]478    suite = unittest.makeSuite(loadASCIITestCase,'test')
[4899]479    runner = unittest.TextTestRunner() #verbosity=2)
[2253]480    runner.run(suite)
[6360]481
Note: See TracBrowser for help on using the repository browser.