WIP-pyshapelib-bramz/test/test_proj.py

# Copyright (c) 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Test the Thuban-specific Projection class
"""

__version__ = "$Revision$"
# $Source$
# $Id$

import unittest
import os

import xmlsupport
import support
support.initthuban()

from Thuban import _
from Thuban.Model.proj import Projection, ProjFile, \
     PROJ_UNITS_METERS, PROJ_UNITS_DEGREES
from Thuban.Model.messages import PROJECTION_ADDED, PROJECTION_REMOVED, \
     PROJECTION_REPLACED
import Thuban.Model.resource as resource

from xmlsupport import sax_eventlist

from xml.sax import SAXParseException


class TestProjection(unittest.TestCase, support.FloatComparisonMixin):

    """Test cases for the Thuban-specific Projection class
    """

    def test(self):
        """Test Projection"""
        params = ["zone=26", "proj=utm", "ellps=clrk66"]
        proj = Projection(params)
        self.assertEquals(proj.params, params)

        # It's not clear whether this value is really the correct one
        # but a test failure here probably still means a bug somewhere
        self.assertFloatSeqEqual(proj.Forward(0, 0),
                                 [3623101.8103431347, 0.0],
                                 epsilon = 1e-5)
        self.assertFloatSeqEqual(proj.Inverse(3623101.8103431347, 0.0),
                                 [-0.00065775699878736467, 0])

        self.assertFloatSeqEqual(proj.ForwardBBox((0, 0, 2, 2)),
                                 (3620891.3077618643, 0.0,
                                  3875381.8535437919, 252962.10480170773),
                                 epsilon = 1e-5)

        # GetName()
        self.assertEquals(proj.GetName(), _("Unknown"))

        # GetParameter()
        self.assertEquals(proj.GetParameter("zone"), "26")
        self.assertEquals(proj.GetParameter("proj"), "utm")
        self.assertEquals(proj.GetParameter("ellps"), "clrk66")
        self.assertEquals(proj.GetParameter("hallo"), "")

        # GetAllParameters()
        self.assertEquals(proj.GetAllParameters(), params)

        # GetName()
        proj = Projection(params, "MyName")
        self.assertEquals(proj.GetName(), "MyName")

    def test_get_parameter_without_equals_sign(self):
        """Test Projection.GetParameter() for a parameter without '=' sign"""
        proj = Projection(["proj=utm", "zone=34", "south", "ellps=clrk66"])
        # The Projection class pretends that for parameters specified
        # without a value the value is the same as the parameter name.
        self.assertEquals(proj.GetParameter("south"), "south")

    def test_get_projection_units_geo(self):
        """Test Projection.GetProjectedUnits() for geographic projection"""
        proj = Projection(["proj=latlong", "to_meter=0.017453292519943295",
                           "ellps=clrk66"])
        self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_DEGREES)

    def test_get_projection_units_normal(self):
        """Test Projection.GetProjectedUnits() for normal projection"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_METERS)

    def test_label(self):
        """Test Projection.Label() without epsg"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
                           name = "My Projection")
        self.assertEquals(proj.Label(), "My Projection")

    def test_label_epsg(self):
        """Test Projection.Label() with epsg"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
                           name = "My Projection", epsg="42")
        self.assertEquals(proj.Label(), "EPSG    42 My Projection")

    def test_epsgcode_for_non_epsg_projection(self):
        """Test Projection.EPSGCode() without epsg"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
                           name = "My Projection")
        self.assertEquals(proj.EPSGCode(), None)

    def test_epsgcode_for_real_epsg_projection(self):
        """Test Projection.EPSGCode() with epsg"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
                           name = "My Projection", epsg="42")
        self.assertEquals(proj.EPSGCode(), "42")


class TestProjFileSimple:

    def test_init(self):
        """Test ProjFile coinstructor"""
        proj_file = ProjFile("some_filename")
        self.assertEquals(proj_file.GetFilename(), "some_filename")
        self.assertEquals(len(proj_file.GetProjections()), 0)

    def test_set_filename(self):
        """Test ProjFile.SetFilename()"""
        proj_file = ProjFile("some_filename")
        proj.SetFilename("other_name")
        self.assertEquals(proj_file.GetFilename(), "other_name")


class TestProjFile(unittest.TestCase, support.SubscriberMixin):

    """Test cases for reading and writing projection files.
    """

    def setUp(self):
        self.clear_messages()
        self.proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
        self.proj1 = Projection(["proj=utm", "ellps=clrk66"])
        self.proj2 = Projection(["proj=lcc", "ellps=clrk66",
                                 "lat_1=0", "lat_2=20"])
        self.proj_file = ProjFile("some_filename")
        for msg in [PROJECTION_ADDED, PROJECTION_REMOVED, PROJECTION_REPLACED]:
            self.proj_file.Subscribe(msg, self.subscribe_with_params, msg)

    def test_add_remove(self):
        """Test ProjFile.Add() and ProjFile.Remove()"""
        self.proj_file.Add(self.proj0)
        self.proj_file.Add(self.proj1)
        self.assertEquals(self.proj_file.GetProjections(),
                          [self.proj0, self.proj1])
        self.check_messages([(self.proj0, PROJECTION_ADDED),
                             (self.proj1, PROJECTION_ADDED)])
        self.clear_messages()

        self.proj_file.Remove(self.proj0)
        self.assertEquals(self.proj_file.GetProjections(), [self.proj1])
        self.check_messages([(self.proj0, PROJECTION_REMOVED)])

    def test_remove_non_existing(self):
        """Test ProjFile.Remove(<proj not in projfile>)"""
        self.assertRaises(ValueError, self.proj_file.Remove, self.proj0)
        # Nothing happened, so no messages should have been sent
        self.check_messages([])

    def test_replace(self):
        """Test ProjFile.Replace()"""
        self.proj_file.Add(self.proj0)
        self.proj_file.Add(self.proj1)
        self.clear_messages()

        # Replace()
        self.proj_file.Replace(self.proj0, self.proj2)
        self.assertEquals(self.proj_file.GetProjections(),
                          [self.proj2, self.proj1])
        self.check_messages([(self.proj0, self.proj2, PROJECTION_REPLACED)])

    def test_replace_non_existing(self):
        """Test ProjFile.Replace(<proj not in projfile>, <some proj>)"""
        self.proj_file.Add(self.proj0)
        self.proj_file.Add(self.proj1)
        self.clear_messages()
        self.assertRaises(ValueError,
                          self.proj_file.Replace, self.proj2, self.proj0)
        # All projections should still be there
        self.assertEquals(self.proj_file.GetProjections(),
                          [self.proj0, self.proj1])
        # Nothing happened, so no messages should have been sent
        self.check_messages([])


class ProjFileTest(unittest.TestCase, support.FileTestMixin,
                   xmlsupport.ValidationTest):

    """Base class for the proj file tests that read or write files"""

    def filename(self):
        """Return the filename for the test"""
        return self.temp_file_name(self.id() + ".proj")


class ProjFileReadTests(ProjFileTest):

    """Test read ProjFile objects from files"""

    def test_read_non_existing_file(self):
        """Test read_proj_file with non-existing file"""
        self.assertRaises(IOError,
                          resource.read_proj_file,
                          self.temp_file_name("nonexistent.proj"))

    def test_read_unreadable_file(self):
        """Test read_proj_file with unreadable file

        As currently written this only works on unix-like systems and
        not e.g. on MS Windows.
        """
        filename = self.filename()
        file = open(filename, "w")
        file.close()
        os.chmod(filename, 0200) # write-only
        self.assertRaises(IOError, resource.read_proj_file, filename)

    def test_read_empty_file(self):
        """Test read_proj_file with empty file"""
        filename = self.filename()
        file = open(filename, "w")
        file.close()

        self.assertRaises(SAXParseException, resource.read_proj_file, filename)

    def test_get_system_proj_file(self):
        """Test resource.get_system_proj_file()

        This is primarily to test whether the system proj file contains
        invalid projection paramers and whether the proj file is not
        empty
        """
        projfile, warnings = resource.get_system_proj_file()
        self.assertEquals(warnings, [])
        self.assert_(len(projfile.GetProjections()) > 0)


class WriteProjFileTests(ProjFileTest):

    """Test cases for writing proj files"""

    def compare_xml(self, xml1, xml2):
        self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))

    def doTestWrite(self, projfile, expected):
        filename = self.filename()

        resource.write_proj_file(projfile)

        file = open(filename)
        written_contents = file.read()
        file.close()
        self.compare_xml(written_contents, expected)
        self.validate_data(written_contents)
        self.validate_data(expected)

    def test_write(self):
        """Test write_proj_file"""
        pf = ProjFile(self.filename())
        pf.Add(Projection(['proj=tmerc', 'ellps=clrk66',
                           'lat_0=90w', 'lon_0=90w', 'k=1'],
                          "Transverse Mercator",))
        pf.Add(Projection(["proj=tmerc",
                           "lat_0=0.000000000", "lon_0=-62.000000000",
                           "k=0.999500", "x_0=400000.000", "y_0=0.000",
                           "ellps=clrk80", "units=m"],
                          "Anguilla 1957 / British West Indies Grid",
                          epsg="200"))
        file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
        <projectionlist>
            <projection name="Transverse Mercator">
                <parameter value="proj=tmerc"/>
                <parameter value="ellps=clrk66"/>
                <parameter value="lat_0=90w"/>
                <parameter value="lon_0=90w"/>
                <parameter value="k=1"/>
            </projection>
            <projection epsg="200"
                        name="Anguilla 1957 / British West Indies Grid">
                <parameter value="proj=tmerc"/>
                <parameter value="lat_0=0.000000000"/>
                <parameter value="lon_0=-62.000000000"/>
                <parameter value="k=0.999500"/>
                <parameter value="x_0=400000.000"/>
                <parameter value="y_0=0.000"/>
                <parameter value="ellps=clrk80"/>
                <parameter value="units=m"/>
            </projection>
        </projectionlist>
        '''
        self.doTestWrite(pf, file_contents)

    def test_write_empty_file(self):
        """Test write empty ProjFile"""
        pf = ProjFile(self.filename())
        file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
        <projectionlist>
        </projectionlist>
        '''
        self.doTestWrite(pf, file_contents)


class TestLoadingProjFile(support.FileLoadTestCase):

    file_extension = ".proj"
    file_contents = '''\
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
<projectionlist>
    <projection name="Transverse Mercator">
        <parameter value="proj=tmerc"/>
        <parameter value="ellps=clrk66"/>
        <parameter value="lat_0=90w"/>
        <parameter value="lon_0=90w"/>
        <parameter value="k=1"/>
    </projection>
    <projection epsg="200" name="Anguilla 1957 / British West Indies Grid">
        <parameter value="proj=tmerc"/>
        <parameter value="lat_0=0.000000000"/>
        <parameter value="lon_0=-62.000000000"/>
        <parameter value="k=0.999500"/>
        <parameter value="x_0=400000.000"/>
        <parameter value="y_0=0.000"/>
        <parameter value="ellps=clrk80"/>
        <parameter value="units=m"/>
    </projection>
</projectionlist>
'''

    def check_projection(self, proj, label, parameters):
        """Check the values of the proj's label and parameters"""
        self.assertEquals(proj.Label(), label)
        params = proj.GetAllParameters()[:]
        params.sort()
        self.assertEquals(params, parameters)

    def test(self):
        projfile, warnings = resource.read_proj_file(self.filename())
        # no warnings
        self.assertEquals(warnings, [])

        # There are two projections
        projs = projfile.GetProjections()
        self.assertEquals(len(projs), 2)

        self.check_projection(projs[0],
                              "Transverse Mercator",
                              ['ellps=clrk66', 'k=1', 'lat_0=90w', 'lon_0=90w',
                               'proj=tmerc'])
        self.check_projection(projs[1],
                         "EPSG   200 Anguilla 1957 / British West Indies Grid",
                              ["ellps=clrk80", "k=0.999500",
                               "lat_0=0.000000000", "lon_0=-62.000000000",
                               "proj=tmerc", "units=m",
                               "x_0=400000.000", "y_0=0.000"])


class TestLoadingProjFileWithEmptyProjectionlist(support.FileLoadTestCase):

    file_extension = ".proj"
    file_contents = '''\
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
<projectionlist>
</projectionlist>
'''

    def test(self):
        projfile, warnings = resource.read_proj_file(self.filename())
        # no warnings
        self.assertEquals(warnings, [])

        # There are no projections
        self.assertEquals(len(projfile.GetProjections()), 0)


class TestProjFileWithInvalidParameters(unittest.TestCase,
                                        support.FileLoadTestCase):

    file_extension = ".proj"
    file_contents = '''\
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
<projectionlist>
    <projection name="Universal Transverse Mercator">
        <parameter value="proj=utm"/>
        <parameter value="ellps=clrk66"/>
        <!-- an invalid zone number to trigger the parameter checking
             in the proj library -->
        <parameter value="zone=1000"/>
    </projection>
    <projection name="Transverse Mercator">
        <parameter value="proj=tmerc"/>
        <parameter value="ellps=clrk66"/>
        <parameter value="lat_0=90w"/>
        <parameter value="lon_0=90w"/>
        <parameter value="k=1"/>
    </projection>
</projectionlist>
'''

    def setUp(self):
        support.FileLoadTestCase.setUp(self)

    def test(self):
        """Test reading a proj file with invalid parameters"""
        projfile, warnings = resource.read_proj_file(self.filename())
        projs = projfile.GetProjections()
        self.assertEquals(len(projs), 1)
        params = projs[0].GetAllParameters()[:]
        params.sort()
        self.assertEquals(params, ['ellps=clrk66', 'k=1', 'lat_0=90w',
                                   'lon_0=90w', 'proj=tmerc'])
        self.assertEquals(warnings,
                       ['Error in projection "Universal Transverse Mercator":'
                        ' invalid UTM zone number'])


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