source: trunk/anuga_core/source/anuga/file/test_csv.py @ 7871

Last change on this file since 7871 was 7871, checked in by hudson, 14 years ago

Fixed a couple of errors in the unit test.
File size: 13.7 KB
Line 
1import os
2import unittest
3import tempfile
4import numpy as num
5
6from anuga.utilities.system_tools import get_pathname_from_package
7
8from csv_file import load_csv_as_array, load_csv_as_dict, store_parameters, \
9                        load_csv_as_matrix, load_csv_as_polygons
10
11class Test_csv(unittest.TestCase):
12    def setUp(self):
13        pass
14
15    def tearDown(self):
16        pass
17
18    def _create_csv_file(self):
19        """
20            Create a dummy csv file.
21            Return its filename.
22        """     
23        filename = tempfile.mktemp(".txt")
24        file = open(filename,"w")
25        file.write("elevation, stage\n\
261.0, 3  \n\
270.0, 4 \n\
284.0, 3 \n\
291.0, 6 \n")
30        file.close()
31        return filename
32       
33    def test_get_data_from_file1(self):
34        filename = self._create_csv_file()
35
36        x = load_csv_as_array(filename) 
37       
38        os.remove(filename)
39
40        assert num.allclose(x['elevation'], [1.0, 0.0, 4.0, 1.0])
41        assert num.allclose(x['stage'], [3.0, 4.0, 3.0, 6.0])       
42
43
44    def test_get_data_from_file(self):
45        filename = self._create_csv_file()
46       
47        header,x = load_csv_as_matrix(filename)
48        os.remove(filename)
49       
50        assert num.allclose(x[:,0], [1.0, 0.0,4.0, 1.0])
51
52       
53    def test_store_parameters(self):
54        """tests store temporary file
55        """
56       
57        from os import sep, getenv
58       
59        output_dir=''
60        file_name='details.csv'
61       
62        kwargs = {'file_name':'new2.txt',
63                  'output_dir':output_dir,
64                  'file_name':file_name,
65                  'who':'me',
66                  'what':'detail',
67                  'how':2,
68                  'why':241,
69#                  'completed':345
70                  }
71        store_parameters(verbose=False,**kwargs)
72
73        temp='detail_temp.csv'
74        fid = open(temp)
75        file_header = fid.readline()
76        file_line = fid.readline()
77        fid.close()
78       
79       
80        keys = kwargs.keys()
81        keys.sort()
82        line=''
83        header=''
84        count=0
85        #used the sorted keys to create the header and line data
86        for k in keys:
87#            print "%s = %s" %(k, kwargs[k])
88            header = header+str(k)
89            line = line+str(kwargs[k])
90            count+=1
91            if count <len(kwargs):
92                header = header+','
93                line = line+','
94        header+='\n'
95        line+='\n'
96       
97       
98        #file exists
99        assert os.access(temp, os.F_OK)
100        assert header == file_header
101        assert line == file_line
102       
103        os.remove(temp)
104       
105    def test_store_parameters1(self):
106        """tests store in temporary file and other file
107        """
108       
109        from os import sep, getenv
110       
111        output_dir=''
112        file_name='details.csv'
113       
114        kwargs = {'file_name':'new2.txt',
115                  'output_dir':output_dir,
116                  'file_name':file_name,
117                  'who':'me',
118                  'what':'detail',
119                  'how':2,
120                  'why':241,
121#                  'completed':345
122                  }
123        store_parameters(verbose=False,**kwargs)
124       
125        kwargs['how']=55
126        kwargs['completed']=345
127
128        keys = kwargs.keys()
129        keys.sort()
130        line=''
131        header=''
132        count=0
133        #used the sorted keys to create the header and line data
134        for k in keys:
135#            print "%s = %s" %(k, kwargs[k])
136            header = header+str(k)
137            line = line+str(kwargs[k])
138            count+=1
139            if count <len(kwargs):
140                header = header+','
141                line = line+','
142        header+='\n'
143        line+='\n'
144       
145        kwargs['how']=55
146        kwargs['completed']=345
147       
148        store_parameters(verbose=False,**kwargs)
149       
150#        temp='detail_temp.csv'
151        fid = open(file_name)
152        file_header = fid.readline()
153        file_line1 = fid.readline()
154        file_line2 = fid.readline()
155        fid.close()
156       
157       
158        #file exists
159#        print 'header',header,'line',line
160#        print 'file_header',file_header,'file_line1',file_line1,'file_line2',file_line2
161        assert os.access(file_name, os.F_OK)
162        assert header == file_header
163        assert line == file_line1
164       
165        temp='detail_temp.csv'
166        os.remove(temp)
167        os.remove(file_name)       
168       
169    def test_store_parameters2(self):
170        """tests appending the data to the end of an existing file
171        """
172       
173        from os import sep, getenv
174       
175        output_dir=''
176        file_name='details.csv'
177       
178        kwargs = {'file_name':'new2.txt',
179                  'output_dir':output_dir,
180                  'file_name':file_name,
181                  'who':'me',
182                  'what':'detail',
183                  'how':2,
184                  'why':241,
185                  'completed':345
186                  }
187        store_parameters(verbose=False,**kwargs)
188       
189        kwargs['how']=55
190        kwargs['completed']=23.54532
191       
192        store_parameters(verbose=False,**kwargs)
193       
194        keys = kwargs.keys()
195        keys.sort()
196        line=''
197        header=''
198        count=0
199        #used the sorted keys to create the header and line data
200        for k in keys:
201#            print "%s = %s" %(k, kwargs[k])
202            header = header+str(k)
203            line = line+str(kwargs[k])
204            count+=1
205            if count <len(kwargs):
206                header = header+','
207                line = line+','
208        header+='\n'
209        line+='\n'
210       
211        fid = open(file_name)
212        file_header = fid.readline()
213        file_line1 = fid.readline()
214        file_line2 = fid.readline()
215        fid.close()
216       
217        assert os.access(file_name, os.F_OK)
218        assert header == file_header
219        assert line == file_line2
220       
221        os.remove(file_name)       
222       
223
224   
225    def test_csv2polygons(self):
226        """test loading of a csv polygon file.
227        """
228       
229        path = get_pathname_from_package('anuga.shallow_water')               
230        testfile = os.path.join(path, 'polygon_values_example.csv')               
231
232        polygons, values = load_csv_as_polygons(testfile, 
233                                        value_name='floors')
234
235        assert len(polygons) == 7, 'Must have seven polygons'
236        assert len(values) == 7, 'Must have seven values'
237           
238        # Known floor values
239        floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1}
240       
241        # Known polygon values
242        known_polys = {'1': [[422681.61,871117.55],
243                             [422691.02,871117.60],
244                             [422690.87,871084.23],
245                             [422649.36,871081.85],
246                             [422649.36,871080.39],
247                             [422631.86,871079.50],
248                             [422631.72,871086.75],
249                             [422636.75,871087.20],
250                             [422636.75,871091.50],
251                             [422649.66,871092.09],
252                             [422649.83,871084.91],
253                             [422652.94,871084.90],
254                             [422652.84,871092.39],
255                             [422681.83,871093.73],
256                             [422681.61,871117.55]],
257                       '2': [[422664.22,870785.46],
258                             [422672.48,870780.14],
259                             [422668.17,870772.62],
260                             [422660.35,870777.17],
261                             [422664.22,870785.46]],
262                       '3': [[422661.30,871215.06],
263                             [422667.50,871215.70],
264                             [422668.30,871204.86],
265                             [422662.21,871204.33],
266                             [422661.30,871215.06]],
267                       '4': [[422473.44,871191.22],
268                             [422478.33,871192.26],
269                             [422479.52,871186.03],
270                             [422474.78,871185.14],
271                             [422473.44,871191.22]],
272                       '5': [[422369.69,871049.29],
273                             [422378.63,871053.58],
274                             [422383.91,871044.51],
275                             [422374.97,871040.32],
276                             [422369.69,871049.29]],
277                       '8': [[422730.56,871203.13],
278                             [422734.10,871204.90],
279                             [422735.26,871202.18],
280                             [422731.87,871200.58],
281                             [422730.56,871203.13]],
282                       '9': [[422659.85,871213.80],
283                             [422660.91,871210.97],
284                             [422655.42,871208.85],
285                             [422654.36,871211.68],
286                             [422659.85,871213.80]]
287                       }       
288       
289
290       
291               
292        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
293            assert id in polygons.keys()
294            assert id in values.keys()           
295
296            assert int(values[id]) == int(floors[id])
297            assert len(polygons[id]) == len(known_polys[id])
298            assert num.allclose(polygons[id], known_polys[id])
299
300
301    def test_csv2polygons_with_clipping(self):
302        """test_csv2polygons with optional clipping
303        """
304        #FIXME(Ole): Not Done!!
305       
306        path = get_pathname_from_package('anuga.shallow_water')               
307        testfile = os.path.join(path, 'polygon_values_example.csv')               
308
309        polygons, values = load_csv_as_polygons(testfile, 
310                                        value_name='floors',
311                                        clipping_polygons=None)
312
313        assert len(polygons) == 7, 'Must have seven polygons'
314        assert len(values) == 7, 'Must have seven values'
315           
316        # Known floor values
317        floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1}
318       
319        # Known polygon values
320        known_polys = {'1': [[422681.61,871117.55],
321                             [422691.02,871117.60],
322                             [422690.87,871084.23],
323                             [422649.36,871081.85],
324                             [422649.36,871080.39],
325                             [422631.86,871079.50],
326                             [422631.72,871086.75],
327                             [422636.75,871087.20],
328                             [422636.75,871091.50],
329                             [422649.66,871092.09],
330                             [422649.83,871084.91],
331                             [422652.94,871084.90],
332                             [422652.84,871092.39],
333                             [422681.83,871093.73],
334                             [422681.61,871117.55]],
335                       '2': [[422664.22,870785.46],
336                             [422672.48,870780.14],
337                             [422668.17,870772.62],
338                             [422660.35,870777.17],
339                             [422664.22,870785.46]],
340                       '3': [[422661.30,871215.06],
341                             [422667.50,871215.70],
342                             [422668.30,871204.86],
343                             [422662.21,871204.33],
344                             [422661.30,871215.06]],
345                       '4': [[422473.44,871191.22],
346                             [422478.33,871192.26],
347                             [422479.52,871186.03],
348                             [422474.78,871185.14],
349                             [422473.44,871191.22]],
350                       '5': [[422369.69,871049.29],
351                             [422378.63,871053.58],
352                             [422383.91,871044.51],
353                             [422374.97,871040.32],
354                             [422369.69,871049.29]],
355                       '8': [[422730.56,871203.13],
356                             [422734.10,871204.90],
357                             [422735.26,871202.18],
358                             [422731.87,871200.58],
359                             [422730.56,871203.13]],
360                       '9': [[422659.85,871213.80],
361                             [422660.91,871210.97],
362                             [422655.42,871208.85],
363                             [422654.36,871211.68],
364                             [422659.85,871213.80]]
365                       }       
366       
367
368       
369               
370        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
371            assert id in polygons.keys()
372            assert id in values.keys()           
373
374            assert int(values[id]) == int(floors[id])
375            assert len(polygons[id]) == len(known_polys[id])
376            assert num.allclose(polygons[id], known_polys[id])
377
378
379
380
381   
382    def test_csv2building_polygons(self):
383        """test_csv2building_polygons
384        """
385       
386        path = get_pathname_from_package('anuga.shallow_water')               
387        testfile = os.path.join(path, 'polygon_values_example.csv')               
388
389        polygons, values = load_csv_as_building_polygons(testfile, 
390                                                 floor_height=3)
391
392        assert len(polygons) == 7, 'Must have seven polygons'
393        assert len(values) == 7, 'Must have seven values'
394           
395        # Known floor values
396        floors = {'1': 6, '2': 0, '3': 3, '4': 6, '5': 0, '8': 3, '9': 3}
397       
398               
399        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
400            assert id in polygons.keys()
401            assert id in values.keys()           
402
403            assert float(values[id]) == float(floors[id])
404
405
406
407#################################################################################
408
409if __name__ == "__main__":
410    suite = unittest.makeSuite(Test_csv, 'test')
411    runner = unittest.TextTestRunner(verbosity=1)
412    runner.run(suite)
Note: See TracBrowser for help on using the repository browser.