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

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 ProjFileTest(unittest.TestCase, support.FileTestMixin):

    """Base class for the proj file tests"""

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


class TestProjFile(ProjFileTest, xmlsupport.ValidationTest):

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

    def test(self):
        """Test ProjFile"""

        proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
        proj1 = Projection(["proj=utm", "ellps=clrk66"])
        proj2 = Projection(["proj=lcc", "ellps=clrk66",
                            "lat_1=0", "lat_2=20"])

        eq = self.assertEquals


        #
        # __init__()
        # GetFilename()
        # SetFilename()
        #
        for name in ["", "hello_world"]:
            projFile = ProjFile(name)
            eq(projFile.GetFilename(), name)

            projFile.SetFilename("XXX")
            projFile.SetFilename(name)
            eq(projFile.GetFilename(), name)

        # initial number of projections should be 0
        eq(len(projFile.GetProjections()), 0)

        #
        # Add()
        # Remove()
        #
        projFile.Add(proj0)
        eq(len(projFile.GetProjections()), 1)
        projFile.Remove(proj0)
        eq(len(projFile.GetProjections()), 0)

        # try to remove something that doesn't exist
        self.assertRaises(ValueError, projFile.Remove, None)
        self.assertRaises(ValueError, projFile.Remove, proj0)

        projFile.Add(proj0)
        projFile.Add(proj1)
        projFile.Add(proj2)
        eq(len(projFile.GetProjections()), 3)

        # GetProjections() -- tests order
        projs = projFile.GetProjections()
        eq(projs[0], proj0)
        eq(projs[1], proj1)
        eq(projs[2], proj2)

        projFile.Remove(proj2)
        projFile.Remove(proj1)

        # Replace()
        projFile.Replace(proj0, proj1)
        projs = projFile.GetProjections()
        eq(projs[0], proj1)

        # replace a non-existent projection
        self.assertRaises(ValueError, projFile.Replace, None, proj2)
        self.assertRaises(ValueError, projFile.Replace, proj0, proj2)

    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, xmlsupport.ValidationTest):

    """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	bh	1259	# Copyright (c) 2002, 2003 by Intevation GmbH
2	bh	333	# 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	jonathan	719	import os
18	bh	333
19	bh	1756	import xmlsupport
20	bh	333	import support
21			support.initthuban()
22
23	bh	1684	from Thuban import _
24	bh	1793	from Thuban.Model.proj import Projection, ProjFile, \
25			PROJ_UNITS_METERS, PROJ_UNITS_DEGREES
26	bh	333
27	jonathan	698	import Thuban.Model.resource as resource
28	bh	333
29	bh	1259	from xmlsupport import sax_eventlist
30	jonathan	698
31	jonathan	719	from xml.sax import SAXParseException
32	jonathan	698
33	jonathan	719
34	bh	333	class TestProjection(unittest.TestCase, support.FloatComparisonMixin):
35
36			"""Test cases for the Thuban-specific Projection class
37			"""
38
39			def test(self):
40			"""Test Projection"""
41	jonathan	761	params = ["zone=26", "proj=utm", "ellps=clrk66"]
42			proj = Projection(params)
43			self.assertEquals(proj.params, params)
44	bh	333
45			# It's not clear whether this value is really the correct one
46			# but a test failure here probably still means a bug somewhere
47			self.assertFloatSeqEqual(proj.Forward(0, 0),
48			[3623101.8103431347, 0.0],
49			epsilon = 1e-5)
50			self.assertFloatSeqEqual(proj.Inverse(3623101.8103431347, 0.0),
51			[-0.00065775699878736467, 0])
52
53			self.assertFloatSeqEqual(proj.ForwardBBox((0, 0, 2, 2)),
54			(3620891.3077618643, 0.0,
55			3875381.8535437919, 252962.10480170773),
56			epsilon = 1e-5)
57
58	jonathan	761	# GetName()
59			self.assertEquals(proj.GetName(), _("Unknown"))
60
61			# GetParameter()
62	jonathan	714	self.assertEquals(proj.GetParameter("zone"), "26")
63			self.assertEquals(proj.GetParameter("proj"), "utm")
64			self.assertEquals(proj.GetParameter("ellps"), "clrk66")
65			self.assertEquals(proj.GetParameter("hallo"), "")
66	bh	333
67	jonathan	761	# GetAllParameters()
68			self.assertEquals(proj.GetAllParameters(), params)
69	bh	333
70	jonathan	761	# GetName()
71			proj = Projection(params, "MyName")
72			self.assertEquals(proj.GetName(), "MyName")
73
74	bh	1798	def test_get_parameter_without_equals_sign(self):
75			"""Test Projection.GetParameter() for a parameter without '=' sign"""
76			proj = Projection(["proj=utm", "zone=34", "south", "ellps=clrk66"])
77			# The Projection class pretends that for parameters specified
78			# without a value the value is the same as the parameter name.
79			self.assertEquals(proj.GetParameter("south"), "south")
80
81	bh	1793	def test_get_projection_units_geo(self):
82			"""Test Projection.GetProjectedUnits() for geographic projection"""
83			proj = Projection(["proj=latlong", "to_meter=0.017453292519943295",
84			"ellps=clrk66"])
85			self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_DEGREES)
86	jonathan	761
87	bh	1793	def test_get_projection_units_normal(self):
88			"""Test Projection.GetProjectedUnits() for normal projection"""
89			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
90			self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_METERS)
91
92	bh	1818	def test_label(self):
93			"""Test Projection.Label() without epsg"""
94			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
95			name = "My Projection")
96			self.assertEquals(proj.Label(), "My Projection")
97	bh	1793
98	bh	1818	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	jonathan	698
104	bh	1818	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	jonathan	698
110	bh	1818	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	jonathan	698
116
117	bh	1813	class ProjFileTest(unittest.TestCase, support.FileTestMixin):
118	jonathan	698
119	bh	1813	"""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	jonathan	698	"""Test cases for reading and writing projection files.
129			"""
130
131	jonathan	742	def test(self):
132			"""Test ProjFile"""
133
134			proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
135			proj1 = Projection(["proj=utm", "ellps=clrk66"])
136	bh	1687	proj2 = Projection(["proj=lcc", "ellps=clrk66",
137			"lat_1=0", "lat_2=20"])
138	jonathan	742
139			eq = self.assertEquals
140
141	jonathan	761
142	jonathan	742	#
143			# __init__()
144			# GetFilename()
145			# SetFilename()
146			#
147			for name in ["", "hello_world"]:
148			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			# Add()
160			# Remove()
161			#
162			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	jonathan	761	self.assertRaises(ValueError, projFile.Remove, None)
169	jonathan	742	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	jonathan	761	projFile.Remove(proj2)
183			projFile.Remove(proj1)
184	jonathan	752
185	jonathan	761	# 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	bh	1811	def test_read_non_existing_file(self):
195			"""Test read_proj_file with non-existing file"""
196	jonathan	719	self.assertRaises(IOError,
197	bh	1811	resource.read_proj_file,
198			self.temp_file_name("nonexistent.proj"))
199	jonathan	719
200	bh	1811	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	bh	1813	filename = self.filename()
207	jonathan	719	file = open(filename, "w")
208			file.close()
209			os.chmod(filename, 0200) # write-only
210	jonathan	1167	self.assertRaises(IOError, resource.read_proj_file, filename)
211	jonathan	719
212	bh	1811	def test_read_empty_file(self):
213			"""Test read_proj_file with empty file"""
214	bh	1813	filename = self.filename()
215	jonathan	719	file = open(filename, "w")
216			file.close()
217
218	jonathan	1167	self.assertRaises(SAXParseException, resource.read_proj_file, filename)
219	jonathan	719
220	bh	1787	def test_get_system_proj_file(self):
221			"""Test resource.get_system_proj_file()
222	jonathan	698
223	bh	1787	This is primarily to test whether the system proj file contains
224			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
231
232	bh	1813	class WriteProjFileTests(ProjFileTest, xmlsupport.ValidationTest):
233
234			"""Test cases for writing proj files"""
235
236			def compare_xml(self, xml1, xml2):
237			self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
238
239	bh	1818	def doTestWrite(self, projfile, expected):
240	bh	1813	filename = self.filename()
241
242	bh	1818	resource.write_proj_file(projfile)
243	bh	1813
244			file = open(filename)
245			written_contents = file.read()
246			file.close()
247			self.compare_xml(written_contents, expected)
248			self.validate_data(written_contents)
249			self.validate_data(expected)
250
251			def test_write(self):
252			"""Test write_proj_file"""
253	bh	1818	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	bh	1813
288			def test_write_empty_file(self):
289			"""Test write empty ProjFile"""
290	bh	1818	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	bh	1813
298
299	bh	1818	class TestLoadingProjFile(support.FileLoadTestCase):
300
301			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
372
373	bh	1787	class TestProjFileWithInvalidParameters(unittest.TestCase,
374			support.FileLoadTestCase):
375
376			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	bh	333	if __name__ == "__main__":
416			unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision