/[thuban]/branches/WIP-pyshapelib-bramz/test/test_proj.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/test/test_proj.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 714 by jonathan, Wed Apr 23 08:47:05 2003 UTC revision 1821 by bh, Tue Oct 14 13:54:03 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2002 by Intevation GmbH  # Copyright (c) 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  #  #
# Line 14  __version__ = "$Revision$" Line 14  __version__ = "$Revision$"
14  # $Id$  # $Id$
15    
16  import unittest  import unittest
17    import os
18    
19    import xmlsupport
20  import support  import support
21  support.initthuban()  support.initthuban()
22    
23  from Thuban.Model.proj import Projection, ProjFile  from Thuban import _
24    from Thuban.Model.proj import Projection, ProjFile, \
25         PROJ_UNITS_METERS, PROJ_UNITS_DEGREES
26    
27  import Thuban.Model.resource as resource  import Thuban.Model.resource as resource
28    
29  from test_save import sax_eventlist  from xmlsupport import sax_eventlist
30    
31    from xml.sax import SAXParseException
32    
33    
34  class TestProjection(unittest.TestCase, support.FloatComparisonMixin):  class TestProjection(unittest.TestCase, support.FloatComparisonMixin):
# Line 32  class TestProjection(unittest.TestCase, Line 38  class TestProjection(unittest.TestCase,
38    
39      def test(self):      def test(self):
40          """Test Projection"""          """Test Projection"""
41          proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])          params = ["zone=26", "proj=utm", "ellps=clrk66"]
42          self.assertEquals(proj.params, ["zone=26", "proj=utm", "ellps=clrk66"])          proj = Projection(params)
43            self.assertEquals(proj.params, params)
44    
45          # It's not clear whether this value is really the correct one          # It's not clear whether this value is really the correct one
46          # but a test failure here probably still means a bug somewhere          # but a test failure here probably still means a bug somewhere
# Line 48  class TestProjection(unittest.TestCase, Line 55  class TestProjection(unittest.TestCase,
55                                    3875381.8535437919, 252962.10480170773),                                    3875381.8535437919, 252962.10480170773),
56                                   epsilon = 1e-5)                                   epsilon = 1e-5)
57    
58            # GetName()
59            self.assertEquals(proj.GetName(), _("Unknown"))
60    
61            # GetParameter()
62          self.assertEquals(proj.GetParameter("zone"), "26")          self.assertEquals(proj.GetParameter("zone"), "26")
63          self.assertEquals(proj.GetParameter("proj"), "utm")          self.assertEquals(proj.GetParameter("proj"), "utm")
64          self.assertEquals(proj.GetParameter("ellps"), "clrk66")          self.assertEquals(proj.GetParameter("ellps"), "clrk66")
65          self.assertEquals(proj.GetParameter("hallo"), "")          self.assertEquals(proj.GetParameter("hallo"), "")
66    
67            # GetAllParameters()
68            self.assertEquals(proj.GetAllParameters(), params)
69    
70  sample_projfile = '''\          # GetName()
71  <?xml version="1.0" encoding="UTF-8"?>          proj = Projection(params, "MyName")
72  <!DOCTYPE projfile SYSTEM "thuban.dtd">          self.assertEquals(proj.GetName(), "MyName")
73  <projectionlist>  
74      <projection name="Transverse Mercartor">      def test_get_parameter_without_equals_sign(self):
75          <parameter value="proj=tmerc"/>          """Test Projection.GetParameter() for a parameter without '=' sign"""
76          <parameter value="ellps=clrk66"/>          proj = Projection(["proj=utm", "zone=34", "south", "ellps=clrk66"])
77          <parameter value="lat_0=90w"/>          # The Projection class pretends that for parameters specified
78          <parameter value="lon_0=90w"/>          # without a value the value is the same as the parameter name.
79          <parameter value="k=1"/>          self.assertEquals(proj.GetParameter("south"), "south")
80      </projection>  
81      <projection name="Transverse Mercartor">      def test_get_projection_units_geo(self):
82          <parameter value="proj=tmerc"/>          """Test Projection.GetProjectedUnits() for geographic projection"""
83          <parameter value="ellps=clrk66"/>          proj = Projection(["proj=latlong", "to_meter=0.017453292519943295",
84          <parameter value="lat_0=30w"/>                             "ellps=clrk66"])
85          <parameter value="lon_0=30w"/>          self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_DEGREES)
         <parameter value="k=1"/>  
     </projection>  
     <projection name="Universal Transverse Mercartor">  
         <parameter value="proj=utm"/>  
         <parameter value="ellps=clrk66"/>  
         <parameter value="zone=1"/>  
     </projection>  
 </projectionlist>  
 '''  
86    
87  sample_projfile_data = [("Transverse Mercartor", ["proj=tmerc",      def test_get_projection_units_normal(self):
88                                                    "ellps=clrk66",          """Test Projection.GetProjectedUnits() for normal projection"""
89                                                    "lat_0=90w",          proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
90                                                    "lon_0=90w",          self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_METERS)
91                                                    "k=1"]),  
92                          ("Transverse Mercartor", ["proj=tmerc",      def test_label(self):
93                                                    "ellps=clrk66",          """Test Projection.Label() without epsg"""
94                                                    "lat_0=30w",          proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
95                                                    "lon_0=30w",                             name = "My Projection")
96                                                    "k=1"]),          self.assertEquals(proj.Label(), "My Projection")
97                          ("Universal Transverse Mercartor", ["proj=utm",  
98                                                              "ellps=clrk66",      def test_label_epsg(self):
99                                                              "zone=1"])]          """Test Projection.Label() with epsg"""
100            proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
101                               name = "My Projection", epsg="42")
102            self.assertEquals(proj.Label(), "EPSG    42 My Projection")
103    
104        def test_epsgcode_for_non_epsg_projection(self):
105            """Test Projection.EPSGCode() without epsg"""
106            proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
107                               name = "My Projection")
108            self.assertEquals(proj.EPSGCode(), None)
109    
110        def test_epsgcode_for_real_epsg_projection(self):
111            """Test Projection.EPSGCode() with epsg"""
112            proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
113                               name = "My Projection", epsg="42")
114            self.assertEquals(proj.EPSGCode(), "42")
115    
 sample_projfile2 = '''\  
 <?xml version="1.0" encoding="UTF-8"?>  
 <!DOCTYPE projfile SYSTEM "thuban.dtd">  
 <projectionlist>  
 </projectionlist>  
 '''  
116    
 sample_projfile_data2 = []  
117    
118  class TestProjFile(unittest.TestCase, support.FileTestMixin):  class TestProjFileSimple:
119    
120        def test_init(self):
121            """Test ProjFile coinstructor"""
122            proj_file = ProjFile("some_filename")
123            self.assertEquals(proj_file.GetFilename(), "some_filename")
124            self.assertEquals(len(proj_file.GetProjections()), 0)
125    
126        def test_set_filename(self):
127            """Test ProjFile.SetFilename()"""
128            proj_file = ProjFile("some_filename")
129            proj.SetFilename("other_name")
130            self.assertEquals(proj_file.GetFilename(), "other_name")
131    
132    
133    class TestProjFile(unittest.TestCase):
134    
135      """Test cases for reading and writing projection files.      """Test cases for reading and writing projection files.
136      """      """
137    
138      def compare_xml(self, xml1, xml2):      def setUp(self):
139          self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))          self.proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
140            self.proj1 = Projection(["proj=utm", "ellps=clrk66"])
141            self.proj2 = Projection(["proj=lcc", "ellps=clrk66",
142                                     "lat_1=0", "lat_2=20"])
143    
144        def test_add_remove(self):
145            """Test ProjFile.Add() and ProjFile.Remove()"""
146            proj_file = ProjFile("some_filename")
147            proj_file.Add(self.proj0)
148            proj_file.Add(self.proj1)
149            self.assertEquals(proj_file.GetProjections(), [self.proj0, self.proj1])
150            proj_file.Remove(self.proj0)
151            self.assertEquals(proj_file.GetProjections(), [self.proj1])
152    
153        def test_remove_non_existing(self):
154            """Test ProjFile.Remove(<proj not in projfile>)"""
155            proj_file = ProjFile("some_filename")
156            self.assertRaises(ValueError, proj_file.Remove, self.proj0)
157    
158        def test_replace(self):
159            """Test ProjFile.Replace()"""
160            proj_file = ProjFile("some_filename")
161            proj_file.Add(self.proj0)
162            proj_file.Add(self.proj1)
163    
164            # Replace()
165            proj_file.Replace(self.proj0, self.proj2)
166            self.assertEquals(proj_file.GetProjections(), [self.proj2, self.proj1])
167    
168        def test_replace_non_existing(self):
169            """Test ProjFile.Replace(<proj not in projfile>, <some proj>)"""
170            proj_file = ProjFile("some_filename")
171            proj_file.Add(self.proj0)
172            proj_file.Add(self.proj1)
173            self.assertRaises(ValueError,
174                              proj_file.Replace, self.proj2, self.proj0)
175    
176    
177    class ProjFileTest(unittest.TestCase, support.FileTestMixin,
178                       xmlsupport.ValidationTest):
179    
180        """Base class for the proj file tests that read or write files"""
181    
182        def filename(self):
183            """Return the filename for the test"""
184            return self.temp_file_name(self.id() + ".proj")
185    
186    
187    class ProjFileReadTests(ProjFileTest):
188    
189        """Test read ProjFile objects from files"""
190    
191        def test_read_non_existing_file(self):
192            """Test read_proj_file with non-existing file"""
193            self.assertRaises(IOError,
194                              resource.read_proj_file,
195                              self.temp_file_name("nonexistent.proj"))
196    
197        def test_read_unreadable_file(self):
198            """Test read_proj_file with unreadable file
199    
200            As currently written this only works on unix-like systems and
201            not e.g. on MS Windows.
202            """
203            filename = self.filename()
204            file = open(filename, "w")
205            file.close()
206            os.chmod(filename, 0200) # write-only
207            self.assertRaises(IOError, resource.read_proj_file, filename)
208    
209        def test_read_empty_file(self):
210            """Test read_proj_file with empty file"""
211            filename = self.filename()
212            file = open(filename, "w")
213            file.close()
214    
215            self.assertRaises(SAXParseException, resource.read_proj_file, filename)
216    
217      def testRead(self):      def test_get_system_proj_file(self):
218          """Test ReadProjFile"""          """Test resource.get_system_proj_file()
219    
220          self.doTestRead(sample_projfile_data, sample_projfile)          This is primarily to test whether the system proj file contains
221          self.doTestRead(sample_projfile_data2, sample_projfile2)          invalid projection paramers and whether the proj file is not
222            empty
223            """
224            projfile, warnings = resource.get_system_proj_file()
225            self.assertEquals(warnings, [])
226            self.assert_(len(projfile.GetProjections()) > 0)
227    
     def testWrite(self):  
         """Test WriteProjFile"""  
228    
229          self.doTestWrite(sample_projfile_data, sample_projfile)  class WriteProjFileTests(ProjFileTest):
         self.doTestWrite(sample_projfile_data2, sample_projfile2)  
230    
231      def doTestWrite(self, data, expected):      """Test cases for writing proj files"""
232    
233          filename = self.temp_file_name("projfile.proj")      def compare_xml(self, xml1, xml2):
234            self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
235    
236          pf = ProjFile(filename)      def doTestWrite(self, projfile, expected):
237          for proj in data:          filename = self.filename()
             pf.Add(Projection(proj[1], proj[0]))  
238    
239          resource.WriteProjFile(pf)          resource.write_proj_file(projfile)
240    
241          file = open(filename)          file = open(filename)
242          written_contents = file.read()          written_contents = file.read()
243          file.close()          file.close()
244          self.compare_xml(written_contents, expected)          self.compare_xml(written_contents, expected)
245            self.validate_data(written_contents)
246            self.validate_data(expected)
247    
248      def doTestRead(self, data, input):      def test_write(self):
249            """Test write_proj_file"""
250            pf = ProjFile(self.filename())
251            pf.Add(Projection(['proj=tmerc', 'ellps=clrk66',
252                               'lat_0=90w', 'lon_0=90w', 'k=1'],
253                              "Transverse Mercator",))
254            pf.Add(Projection(["proj=tmerc",
255                               "lat_0=0.000000000", "lon_0=-62.000000000",
256                               "k=0.999500", "x_0=400000.000", "y_0=0.000",
257                               "ellps=clrk80", "units=m"],
258                              "Anguilla 1957 / British West Indies Grid",
259                              epsg="200"))
260            file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
261            <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
262            <projectionlist>
263                <projection name="Transverse Mercator">
264                    <parameter value="proj=tmerc"/>
265                    <parameter value="ellps=clrk66"/>
266                    <parameter value="lat_0=90w"/>
267                    <parameter value="lon_0=90w"/>
268                    <parameter value="k=1"/>
269                </projection>
270                <projection epsg="200"
271                            name="Anguilla 1957 / British West Indies Grid">
272                    <parameter value="proj=tmerc"/>
273                    <parameter value="lat_0=0.000000000"/>
274                    <parameter value="lon_0=-62.000000000"/>
275                    <parameter value="k=0.999500"/>
276                    <parameter value="x_0=400000.000"/>
277                    <parameter value="y_0=0.000"/>
278                    <parameter value="ellps=clrk80"/>
279                    <parameter value="units=m"/>
280                </projection>
281            </projectionlist>
282            '''
283            self.doTestWrite(pf, file_contents)
284    
285        def test_write_empty_file(self):
286            """Test write empty ProjFile"""
287            pf = ProjFile(self.filename())
288            file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
289            <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
290            <projectionlist>
291            </projectionlist>
292            '''
293            self.doTestWrite(pf, file_contents)
294    
         filename = self.temp_file_name("projfile.proj")  
         file = open(filename, "w")  
         file.write(input)  
         file.close()  
295    
296          pf = resource.ReadProjFile(filename)  class TestLoadingProjFile(support.FileLoadTestCase):
297    
298        file_extension = ".proj"
299        file_contents = '''\
300    <?xml version="1.0" encoding="UTF-8"?>
301    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
302    <projectionlist>
303        <projection name="Transverse Mercator">
304            <parameter value="proj=tmerc"/>
305            <parameter value="ellps=clrk66"/>
306            <parameter value="lat_0=90w"/>
307            <parameter value="lon_0=90w"/>
308            <parameter value="k=1"/>
309        </projection>
310        <projection epsg="200" name="Anguilla 1957 / British West Indies Grid">
311            <parameter value="proj=tmerc"/>
312            <parameter value="lat_0=0.000000000"/>
313            <parameter value="lon_0=-62.000000000"/>
314            <parameter value="k=0.999500"/>
315            <parameter value="x_0=400000.000"/>
316            <parameter value="y_0=0.000"/>
317            <parameter value="ellps=clrk80"/>
318            <parameter value="units=m"/>
319        </projection>
320    </projectionlist>
321    '''
322    
323        def check_projection(self, proj, label, parameters):
324            """Check the values of the proj's label and parameters"""
325            self.assertEquals(proj.Label(), label)
326            params = proj.GetAllParameters()[:]
327            params.sort()
328            self.assertEquals(params, parameters)
329    
330        def test(self):
331            projfile, warnings = resource.read_proj_file(self.filename())
332            # no warnings
333            self.assertEquals(warnings, [])
334    
335            # There are two projections
336            projs = projfile.GetProjections()
337            self.assertEquals(len(projs), 2)
338    
339            self.check_projection(projs[0],
340                                  "Transverse Mercator",
341                                  ['ellps=clrk66', 'k=1', 'lat_0=90w', 'lon_0=90w',
342                                   'proj=tmerc'])
343            self.check_projection(projs[1],
344                             "EPSG   200 Anguilla 1957 / British West Indies Grid",
345                                  ["ellps=clrk80", "k=0.999500",
346                                   "lat_0=0.000000000", "lon_0=-62.000000000",
347                                   "proj=tmerc", "units=m",
348                                   "x_0=400000.000", "y_0=0.000"])
349    
350    
351          eq = self.assertEquals  class TestLoadingProjFileWithEmptyProjectionlist(support.FileLoadTestCase):
352    
353          eq(pf.GetFileName(), filename)      file_extension = ".proj"
354        file_contents = '''\
355    <?xml version="1.0" encoding="UTF-8"?>
356    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
357    <projectionlist>
358    </projectionlist>
359    '''
360    
361          for proj, d in zip(pf.GetProjections(), data):      def test(self):
362              eq(proj.GetName(), d[0])          projfile, warnings = resource.read_proj_file(self.filename())
363              for param in proj.GetAllParameters():          # no warnings
364                  self.assert_(param in d[1])          self.assertEquals(warnings, [])
365    
366            # There are no projections
367            self.assertEquals(len(projfile.GetProjections()), 0)
368    
369    
370    class TestProjFileWithInvalidParameters(unittest.TestCase,
371                                            support.FileLoadTestCase):
372    
373        file_extension = ".proj"
374        file_contents = '''\
375    <?xml version="1.0" encoding="UTF-8"?>
376    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
377    <projectionlist>
378        <projection name="Universal Transverse Mercator">
379            <parameter value="proj=utm"/>
380            <parameter value="ellps=clrk66"/>
381            <!-- an invalid zone number to trigger the parameter checking
382                 in the proj library -->
383            <parameter value="zone=1000"/>
384        </projection>
385        <projection name="Transverse Mercator">
386            <parameter value="proj=tmerc"/>
387            <parameter value="ellps=clrk66"/>
388            <parameter value="lat_0=90w"/>
389            <parameter value="lon_0=90w"/>
390            <parameter value="k=1"/>
391        </projection>
392    </projectionlist>
393    '''
394    
395        def setUp(self):
396            support.FileLoadTestCase.setUp(self)
397    
398        def test(self):
399            """Test reading a proj file with invalid parameters"""
400            projfile, warnings = resource.read_proj_file(self.filename())
401            projs = projfile.GetProjections()
402            self.assertEquals(len(projs), 1)
403            params = projs[0].GetAllParameters()[:]
404            params.sort()
405            self.assertEquals(params, ['ellps=clrk66', 'k=1', 'lat_0=90w',
406                                       'lon_0=90w', 'proj=tmerc'])
407            self.assertEquals(warnings,
408                           ['Error in projection "Universal Transverse Mercator":'
409                            ' invalid UTM zone number'])
410    
411    
412  if __name__ == "__main__":  if __name__ == "__main__":
Legend:
Removed from v.714  
changed lines
  Added in v.1821
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26