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)


sample_projfile = '''\
<?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 name="Transverse Mercator">
        <parameter value="proj=tmerc"/>
        <parameter value="ellps=clrk66"/>
        <parameter value="lat_0=30w"/>
        <parameter value="lon_0=30w"/>
        <parameter value="k=1"/>
    </projection>
    <projection name="Universal Transverse Mercator">
        <parameter value="proj=utm"/>
        <parameter value="ellps=clrk66"/>
        <parameter value="zone=1"/>
    </projection>
</projectionlist>
'''

sample_projfile_data = [("Transverse Mercator", ["proj=tmerc",
                                                  "ellps=clrk66",
                                                  "lat_0=90w",
                                                  "lon_0=90w",
                                                  "k=1"]),
                        ("Transverse Mercator", ["proj=tmerc",
                                                  "ellps=clrk66",
                                                  "lat_0=30w",
                                                  "lon_0=30w",
                                                  "k=1"]),
                        ("Universal Transverse Mercator", ["proj=utm",
                                                            "ellps=clrk66",
                                                            "zone=1"])]

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

sample_projfile_data2 = []

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

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

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

    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 testRead(self):
        """Test read_proj_file"""
        self.doTestRead(sample_projfile_data, sample_projfile)
        self.doTestRead(sample_projfile_data2, sample_projfile2)

    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.temp_file_name("projfile.proj")
        file = open(filename, "w")
        file.close()
        os.chmod(filename, 0200) # write-only
        self.assertRaises(IOError, resource.read_proj_file, filename)
        os.chmod(filename, 0600) # read/write so we reuse the file

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

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

    def testWrite(self):
        """Test write_proj_file"""

        self.doTestWrite(sample_projfile_data, sample_projfile)
        self.doTestWrite(sample_projfile_data2, sample_projfile2)

    def doTestWrite(self, data, expected):

        filename = self.temp_file_name("projfile.proj")

        pf = ProjFile(filename)
        for proj in data:
            pf.Add(Projection(proj[1], proj[0]))

        resource.write_proj_file(pf)

        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 doTestRead(self, data, input):

        filename = self.temp_file_name("projfile.proj")
        file = open(filename, "w")
        file.write(input)
        file.close()

        pf, warnings = resource.read_proj_file(filename)
        self.assertEquals(warnings, [])

        eq = self.assertEquals

        eq(pf.GetFilename(), filename)

        for proj, d in zip(pf.GetProjections(), data):
            eq(proj.GetName(), d[0])
            for param in proj.GetAllParameters():
                self.assert_(param in d[1])

    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 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
93	jonathan	698	sample_projfile = '''\
94			<?xml version="1.0" encoding="UTF-8"?>
95	bh	1756	<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
96	jonathan	698	<projectionlist>
97	bh	1756	<projection name="Transverse Mercator">
98	jonathan	698	<parameter value="proj=tmerc"/>
99			<parameter value="ellps=clrk66"/>
100			<parameter value="lat_0=90w"/>
101			<parameter value="lon_0=90w"/>
102			<parameter value="k=1"/>
103			</projection>
104	bh	1756	<projection name="Transverse Mercator">
105	jonathan	698	<parameter value="proj=tmerc"/>
106			<parameter value="ellps=clrk66"/>
107			<parameter value="lat_0=30w"/>
108			<parameter value="lon_0=30w"/>
109			<parameter value="k=1"/>
110			</projection>
111	bh	1756	<projection name="Universal Transverse Mercator">
112	jonathan	698	<parameter value="proj=utm"/>
113			<parameter value="ellps=clrk66"/>
114			<parameter value="zone=1"/>
115			</projection>
116			</projectionlist>
117			'''
118
119	bh	1756	sample_projfile_data = [("Transverse Mercator", ["proj=tmerc",
120	jonathan	698	"ellps=clrk66",
121			"lat_0=90w",
122			"lon_0=90w",
123			"k=1"]),
124	bh	1756	("Transverse Mercator", ["proj=tmerc",
125	jonathan	698	"ellps=clrk66",
126			"lat_0=30w",
127			"lon_0=30w",
128			"k=1"]),
129	bh	1756	("Universal Transverse Mercator", ["proj=utm",
130	jonathan	698	"ellps=clrk66",
131			"zone=1"])]
132
133			sample_projfile2 = '''\
134			<?xml version="1.0" encoding="UTF-8"?>
135	bh	1756	<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
136	jonathan	698	<projectionlist>
137			</projectionlist>
138			'''
139
140			sample_projfile_data2 = []
141
142	bh	1756	class TestProjFile(unittest.TestCase, support.FileTestMixin,
143			xmlsupport.ValidationTest):
144	jonathan	698
145			"""Test cases for reading and writing projection files.
146			"""
147
148			def compare_xml(self, xml1, xml2):
149			self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
150
151	jonathan	742	def test(self):
152			"""Test ProjFile"""
153
154			proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
155			proj1 = Projection(["proj=utm", "ellps=clrk66"])
156	bh	1687	proj2 = Projection(["proj=lcc", "ellps=clrk66",
157			"lat_1=0", "lat_2=20"])
158	jonathan	742
159			eq = self.assertEquals
160
161	jonathan	761
162	jonathan	742	#
163			# __init__()
164			# GetFilename()
165			# SetFilename()
166			#
167			for name in ["", "hello_world"]:
168			projFile = ProjFile(name)
169			eq(projFile.GetFilename(), name)
170
171			projFile.SetFilename("XXX")
172			projFile.SetFilename(name)
173			eq(projFile.GetFilename(), name)
174
175			# initial number of projections should be 0
176			eq(len(projFile.GetProjections()), 0)
177
178			#
179			# Add()
180			# Remove()
181			#
182			projFile.Add(proj0)
183			eq(len(projFile.GetProjections()), 1)
184			projFile.Remove(proj0)
185			eq(len(projFile.GetProjections()), 0)
186
187			# try to remove something that doesn't exist
188	jonathan	761	self.assertRaises(ValueError, projFile.Remove, None)
189	jonathan	742	self.assertRaises(ValueError, projFile.Remove, proj0)
190
191			projFile.Add(proj0)
192			projFile.Add(proj1)
193			projFile.Add(proj2)
194			eq(len(projFile.GetProjections()), 3)
195
196			# GetProjections() -- tests order
197			projs = projFile.GetProjections()
198			eq(projs[0], proj0)
199			eq(projs[1], proj1)
200			eq(projs[2], proj2)
201
202	jonathan	761	projFile.Remove(proj2)
203			projFile.Remove(proj1)
204	jonathan	752
205	jonathan	761	# Replace()
206			projFile.Replace(proj0, proj1)
207			projs = projFile.GetProjections()
208			eq(projs[0], proj1)
209
210			# replace a non-existent projection
211			self.assertRaises(ValueError, projFile.Replace, None, proj2)
212			self.assertRaises(ValueError, projFile.Replace, proj0, proj2)
213
214	jonathan	698	def testRead(self):
215	jonathan	1167	"""Test read_proj_file"""
216	jonathan	698	self.doTestRead(sample_projfile_data, sample_projfile)
217			self.doTestRead(sample_projfile_data2, sample_projfile2)
218
219	bh	1811	def test_read_non_existing_file(self):
220			"""Test read_proj_file with non-existing file"""
221	jonathan	719	self.assertRaises(IOError,
222	bh	1811	resource.read_proj_file,
223			self.temp_file_name("nonexistent.proj"))
224	jonathan	719
225	bh	1811	def test_read_unreadable_file(self):
226			"""Test read_proj_file with unreadable file
227
228			As currently written this only works on unix-like systems and
229			not e.g. on MS Windows.
230			"""
231	jonathan	719	filename = self.temp_file_name("projfile.proj")
232			file = open(filename, "w")
233			file.close()
234			os.chmod(filename, 0200) # write-only
235	jonathan	1167	self.assertRaises(IOError, resource.read_proj_file, filename)
236	jonathan	719	os.chmod(filename, 0600) # read/write so we reuse the file
237
238	bh	1811	def test_read_empty_file(self):
239			"""Test read_proj_file with empty file"""
240	jonathan	719	filename = self.temp_file_name("projfile.proj")
241			file = open(filename, "w")
242			file.close()
243
244	jonathan	1167	self.assertRaises(SAXParseException, resource.read_proj_file, filename)
245	jonathan	719
246	jonathan	698	def testWrite(self):
247	jonathan	1167	"""Test write_proj_file"""
248	jonathan	698
249			self.doTestWrite(sample_projfile_data, sample_projfile)
250			self.doTestWrite(sample_projfile_data2, sample_projfile2)
251
252			def doTestWrite(self, data, expected):
253
254			filename = self.temp_file_name("projfile.proj")
255
256			pf = ProjFile(filename)
257			for proj in data:
258			pf.Add(Projection(proj[1], proj[0]))
259
260	jonathan	1167	resource.write_proj_file(pf)
261	jonathan	698
262			file = open(filename)
263			written_contents = file.read()
264			file.close()
265			self.compare_xml(written_contents, expected)
266	bh	1756	self.validate_data(written_contents)
267			self.validate_data(expected)
268	jonathan	698
269			def doTestRead(self, data, input):
270
271			filename = self.temp_file_name("projfile.proj")
272			file = open(filename, "w")
273			file.write(input)
274			file.close()
275
276	bh	1787	pf, warnings = resource.read_proj_file(filename)
277			self.assertEquals(warnings, [])
278	jonathan	698
279			eq = self.assertEquals
280
281	jonathan	742	eq(pf.GetFilename(), filename)
282	jonathan	698
283			for proj, d in zip(pf.GetProjections(), data):
284			eq(proj.GetName(), d[0])
285	jonathan	714	for param in proj.GetAllParameters():
286	jonathan	698	self.assert_(param in d[1])
287
288	bh	1787	def test_get_system_proj_file(self):
289			"""Test resource.get_system_proj_file()
290	jonathan	698
291	bh	1787	This is primarily to test whether the system proj file contains
292			invalid projection paramers and whether the proj file is not
293			empty
294			"""
295			projfile, warnings = resource.get_system_proj_file()
296			self.assertEquals(warnings, [])
297			self.assert_(len(projfile.GetProjections()) > 0)
298
299
300			class TestProjFileWithInvalidParameters(unittest.TestCase,
301			support.FileLoadTestCase):
302
303			file_extension = ".proj"
304			file_contents = '''\
305			<?xml version="1.0" encoding="UTF-8"?>
306			<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
307			<projectionlist>
308			<projection name="Universal Transverse Mercator">
309			<parameter value="proj=utm"/>
310			<parameter value="ellps=clrk66"/>
311			<!-- an invalid zone number to trigger the parameter checking
312			in the proj library -->
313			<parameter value="zone=1000"/>
314			</projection>
315			<projection name="Transverse Mercator">
316			<parameter value="proj=tmerc"/>
317			<parameter value="ellps=clrk66"/>
318			<parameter value="lat_0=90w"/>
319			<parameter value="lon_0=90w"/>
320			<parameter value="k=1"/>
321			</projection>
322			</projectionlist>
323			'''
324
325			def setUp(self):
326			support.FileLoadTestCase.setUp(self)
327
328			def test(self):
329			"""Test reading a proj file with invalid parameters"""
330			projfile, warnings = resource.read_proj_file(self.filename())
331			projs = projfile.GetProjections()
332			self.assertEquals(len(projs), 1)
333			params = projs[0].GetAllParameters()[:]
334			params.sort()
335			self.assertEquals(params, ['ellps=clrk66', 'k=1', 'lat_0=90w',
336			'lon_0=90w', 'proj=tmerc'])
337			self.assertEquals(warnings,
338			['Error in projection "Universal Transverse Mercator":'
339			' invalid UTM zone number'])
340
341
342
343	bh	333	if __name__ == "__main__":
344			unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision