/[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 719 by jonathan, Wed Apr 23 10:40:00 2003 UTC revision 1818 by bh, Mon Oct 13 15:54:14 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 16  __version__ = "$Revision$" Line 16  __version__ = "$Revision$"
16  import unittest  import unittest
17  import os  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  from xml.sax import SAXParseException
32    
# Line 35  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 51  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)
                                                   "k=1"]),  
                         ("Transverse Mercartor", ["proj=tmerc",  
                                                   "ellps=clrk66",  
                                                   "lat_0=30w",  
                                                   "lon_0=30w",  
                                                   "k=1"]),  
                         ("Universal Transverse Mercartor", ["proj=utm",  
                                                             "ellps=clrk66",  
                                                             "zone=1"])]  
91    
92  sample_projfile2 = '''\      def test_label(self):
93  <?xml version="1.0" encoding="UTF-8"?>          """Test Projection.Label() without epsg"""
94  <!DOCTYPE projfile SYSTEM "thuban.dtd">          proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
95  <projectionlist>                             name = "My Projection")
96  </projectionlist>          self.assertEquals(proj.Label(), "My Projection")
 '''  
97    
98  sample_projfile_data2 = []      def test_label_epsg(self):
99            """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  class TestProjFile(unittest.TestCase, support.FileTestMixin):      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    
116    
117    class ProjFileTest(unittest.TestCase, support.FileTestMixin):
118    
119        """Base class for the proj file tests"""
120    
121        def filename(self):
122            """Return the filename for the test"""
123            return self.temp_file_name(self.id() + ".proj")
124    
125    
126    class TestProjFile(ProjFileTest, xmlsupport.ValidationTest):
127    
128      """Test cases for reading and writing projection files.      """Test cases for reading and writing projection files.
129      """      """
130    
131      def compare_xml(self, xml1, xml2):      def test(self):
132          self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))          """Test ProjFile"""
133    
134            proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
135            proj1 = Projection(["proj=utm", "ellps=clrk66"])
136            proj2 = Projection(["proj=lcc", "ellps=clrk66",
137                                "lat_1=0", "lat_2=20"])
138    
139      def testRead(self):          eq = self.assertEquals
         """Test ReadProjFile"""  
140    
         self.doTestRead(sample_projfile_data, sample_projfile)  
         self.doTestRead(sample_projfile_data2, sample_projfile2)  
141    
142          #          #
143          # file doesn't exist          # __init__()
144            # GetFilename()
145            # SetFilename()
146          #          #
147          self.assertRaises(IOError,          for name in ["", "hello_world"]:
148              resource.ReadProjFile, self.temp_file_name("nonexistent.proj"))              projFile = ProjFile(name)
149                eq(projFile.GetFilename(), name)
150    
151                projFile.SetFilename("XXX")
152                projFile.SetFilename(name)
153                eq(projFile.GetFilename(), name)
154    
155            # initial number of projections should be 0
156            eq(len(projFile.GetProjections()), 0)
157    
158          #          #
159          # file isn't readable          # Add()
160            # Remove()
161          #          #
162          filename = self.temp_file_name("projfile.proj")          projFile.Add(proj0)
163            eq(len(projFile.GetProjections()), 1)
164            projFile.Remove(proj0)
165            eq(len(projFile.GetProjections()), 0)
166    
167            # try to remove something that doesn't exist
168            self.assertRaises(ValueError, projFile.Remove, None)
169            self.assertRaises(ValueError, projFile.Remove, proj0)
170    
171            projFile.Add(proj0)
172            projFile.Add(proj1)
173            projFile.Add(proj2)
174            eq(len(projFile.GetProjections()), 3)
175    
176            # GetProjections() -- tests order
177            projs = projFile.GetProjections()
178            eq(projs[0], proj0)
179            eq(projs[1], proj1)
180            eq(projs[2], proj2)
181    
182            projFile.Remove(proj2)
183            projFile.Remove(proj1)
184    
185            # Replace()
186            projFile.Replace(proj0, proj1)
187            projs = projFile.GetProjections()
188            eq(projs[0], proj1)
189    
190            # replace a non-existent projection
191            self.assertRaises(ValueError, projFile.Replace, None, proj2)
192            self.assertRaises(ValueError, projFile.Replace, proj0, proj2)
193    
194        def test_read_non_existing_file(self):
195            """Test read_proj_file with non-existing file"""
196            self.assertRaises(IOError,
197                              resource.read_proj_file,
198                              self.temp_file_name("nonexistent.proj"))
199    
200        def test_read_unreadable_file(self):
201            """Test read_proj_file with unreadable file
202    
203            As currently written this only works on unix-like systems and
204            not e.g. on MS Windows.
205            """
206            filename = self.filename()
207          file = open(filename, "w")          file = open(filename, "w")
208          file.close()          file.close()
209          os.chmod(filename, 0200) # write-only          os.chmod(filename, 0200) # write-only
210          self.assertRaises(IOError, resource.ReadProjFile, filename)          self.assertRaises(IOError, resource.read_proj_file, filename)
         os.chmod(filename, 0600) # read/write so we reuse the file  
211    
212          #      def test_read_empty_file(self):
213          # file has invalid XML (or none at all)          """Test read_proj_file with empty file"""
214          #          filename = self.filename()
         filename = self.temp_file_name("projfile.proj")  
215          file = open(filename, "w")          file = open(filename, "w")
216          file.close()          file.close()
217    
218          self.assertRaises(SAXParseException, resource.ReadProjFile, filename)          self.assertRaises(SAXParseException, resource.read_proj_file, filename)
219    
220        def test_get_system_proj_file(self):
221            """Test resource.get_system_proj_file()
222    
223      def testWrite(self):          This is primarily to test whether the system proj file contains
224          """Test WriteProjFile"""          invalid projection paramers and whether the proj file is not
225            empty
226            """
227            projfile, warnings = resource.get_system_proj_file()
228            self.assertEquals(warnings, [])
229            self.assert_(len(projfile.GetProjections()) > 0)
230    
         self.doTestWrite(sample_projfile_data, sample_projfile)  
         self.doTestWrite(sample_projfile_data2, sample_projfile2)  
231    
232      def doTestWrite(self, data, expected):  class WriteProjFileTests(ProjFileTest, xmlsupport.ValidationTest):
233    
234          filename = self.temp_file_name("projfile.proj")      """Test cases for writing proj files"""
235    
236          pf = ProjFile(filename)      def compare_xml(self, xml1, xml2):
237          for proj in data:          self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
             pf.Add(Projection(proj[1], proj[0]))  
238    
239          resource.WriteProjFile(pf)      def doTestWrite(self, projfile, expected):
240            filename = self.filename()
241    
242            resource.write_proj_file(projfile)
243    
244          file = open(filename)          file = open(filename)
245          written_contents = file.read()          written_contents = file.read()
246          file.close()          file.close()
247          self.compare_xml(written_contents, expected)          self.compare_xml(written_contents, expected)
248            self.validate_data(written_contents)
249            self.validate_data(expected)
250    
251      def doTestRead(self, data, input):      def test_write(self):
252            """Test write_proj_file"""
253            pf = ProjFile(self.filename())
254            pf.Add(Projection(['proj=tmerc', 'ellps=clrk66',
255                               'lat_0=90w', 'lon_0=90w', 'k=1'],
256                              "Transverse Mercator",))
257            pf.Add(Projection(["proj=tmerc",
258                               "lat_0=0.000000000", "lon_0=-62.000000000",
259                               "k=0.999500", "x_0=400000.000", "y_0=0.000",
260                               "ellps=clrk80", "units=m"],
261                              "Anguilla 1957 / British West Indies Grid",
262                              epsg="200"))
263            file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
264            <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
265            <projectionlist>
266                <projection name="Transverse Mercator">
267                    <parameter value="proj=tmerc"/>
268                    <parameter value="ellps=clrk66"/>
269                    <parameter value="lat_0=90w"/>
270                    <parameter value="lon_0=90w"/>
271                    <parameter value="k=1"/>
272                </projection>
273                <projection epsg="200"
274                            name="Anguilla 1957 / British West Indies Grid">
275                    <parameter value="proj=tmerc"/>
276                    <parameter value="lat_0=0.000000000"/>
277                    <parameter value="lon_0=-62.000000000"/>
278                    <parameter value="k=0.999500"/>
279                    <parameter value="x_0=400000.000"/>
280                    <parameter value="y_0=0.000"/>
281                    <parameter value="ellps=clrk80"/>
282                    <parameter value="units=m"/>
283                </projection>
284            </projectionlist>
285            '''
286            self.doTestWrite(pf, file_contents)
287    
288        def test_write_empty_file(self):
289            """Test write empty ProjFile"""
290            pf = ProjFile(self.filename())
291            file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
292            <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
293            <projectionlist>
294            </projectionlist>
295            '''
296            self.doTestWrite(pf, file_contents)
297    
         filename = self.temp_file_name("projfile.proj")  
         file = open(filename, "w")  
         file.write(input)  
         file.close()  
298    
299          pf = resource.ReadProjFile(filename)  class TestLoadingProjFile(support.FileLoadTestCase):
300    
301          eq = self.assertEquals      file_extension = ".proj"
302        file_contents = '''\
303    <?xml version="1.0" encoding="UTF-8"?>
304    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
305    <projectionlist>
306        <projection name="Transverse Mercator">
307            <parameter value="proj=tmerc"/>
308            <parameter value="ellps=clrk66"/>
309            <parameter value="lat_0=90w"/>
310            <parameter value="lon_0=90w"/>
311            <parameter value="k=1"/>
312        </projection>
313        <projection epsg="200" name="Anguilla 1957 / British West Indies Grid">
314            <parameter value="proj=tmerc"/>
315            <parameter value="lat_0=0.000000000"/>
316            <parameter value="lon_0=-62.000000000"/>
317            <parameter value="k=0.999500"/>
318            <parameter value="x_0=400000.000"/>
319            <parameter value="y_0=0.000"/>
320            <parameter value="ellps=clrk80"/>
321            <parameter value="units=m"/>
322        </projection>
323    </projectionlist>
324    '''
325    
326        def check_projection(self, proj, label, parameters):
327            """Check the values of the proj's label and parameters"""
328            self.assertEquals(proj.Label(), label)
329            params = proj.GetAllParameters()[:]
330            params.sort()
331            self.assertEquals(params, parameters)
332    
333        def test(self):
334            projfile, warnings = resource.read_proj_file(self.filename())
335            # no warnings
336            self.assertEquals(warnings, [])
337    
338            # There are two projections
339            projs = projfile.GetProjections()
340            self.assertEquals(len(projs), 2)
341    
342            self.check_projection(projs[0],
343                                  "Transverse Mercator",
344                                  ['ellps=clrk66', 'k=1', 'lat_0=90w', 'lon_0=90w',
345                                   'proj=tmerc'])
346            self.check_projection(projs[1],
347                             "EPSG   200 Anguilla 1957 / British West Indies Grid",
348                                  ["ellps=clrk80", "k=0.999500",
349                                   "lat_0=0.000000000", "lon_0=-62.000000000",
350                                   "proj=tmerc", "units=m",
351                                   "x_0=400000.000", "y_0=0.000"])
352    
353    
354    class TestLoadingProjFileWithEmptyProjectionlist(support.FileLoadTestCase):
355    
356        file_extension = ".proj"
357        file_contents = '''\
358    <?xml version="1.0" encoding="UTF-8"?>
359    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
360    <projectionlist>
361    </projectionlist>
362    '''
363    
364        def test(self):
365            projfile, warnings = resource.read_proj_file(self.filename())
366            # no warnings
367            self.assertEquals(warnings, [])
368    
369            # There are no projections
370            self.assertEquals(len(projfile.GetProjections()), 0)
371    
         eq(pf.GetFileName(), filename)  
372    
373          for proj, d in zip(pf.GetProjections(), data):  class TestProjFileWithInvalidParameters(unittest.TestCase,
374              eq(proj.GetName(), d[0])                                          support.FileLoadTestCase):
375              for param in proj.GetAllParameters():  
376                  self.assert_(param in d[1])      file_extension = ".proj"
377        file_contents = '''\
378    <?xml version="1.0" encoding="UTF-8"?>
379    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
380    <projectionlist>
381        <projection name="Universal Transverse Mercator">
382            <parameter value="proj=utm"/>
383            <parameter value="ellps=clrk66"/>
384            <!-- an invalid zone number to trigger the parameter checking
385                 in the proj library -->
386            <parameter value="zone=1000"/>
387        </projection>
388        <projection name="Transverse Mercator">
389            <parameter value="proj=tmerc"/>
390            <parameter value="ellps=clrk66"/>
391            <parameter value="lat_0=90w"/>
392            <parameter value="lon_0=90w"/>
393            <parameter value="k=1"/>
394        </projection>
395    </projectionlist>
396    '''
397    
398        def setUp(self):
399            support.FileLoadTestCase.setUp(self)
400    
401        def test(self):
402            """Test reading a proj file with invalid parameters"""
403            projfile, warnings = resource.read_proj_file(self.filename())
404            projs = projfile.GetProjections()
405            self.assertEquals(len(projs), 1)
406            params = projs[0].GetAllParameters()[:]
407            params.sort()
408            self.assertEquals(params, ['ellps=clrk66', 'k=1', 'lat_0=90w',
409                                       'lon_0=90w', 'proj=tmerc'])
410            self.assertEquals(warnings,
411                           ['Error in projection "Universal Transverse Mercator":'
412                            ' invalid UTM zone number'])
413    
414    
415  if __name__ == "__main__":  if __name__ == "__main__":
Legend:
Removed from v.719  
changed lines
  Added in v.1818
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26