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 tearDown(self):
        self.clear_messages()
        self.proj_file.Destroy()

    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__":
    support.run_tests()
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	1825	from Thuban.Model.messages import PROJECTION_ADDED, PROJECTION_REMOVED, \
27			PROJECTION_REPLACED
28	jonathan	698	import Thuban.Model.resource as resource
29	bh	333
30	bh	1259	from xmlsupport import sax_eventlist
31	jonathan	698
32	jonathan	719	from xml.sax import SAXParseException
33	jonathan	698
34	jonathan	719
35	bh	333	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	jonathan	761	params = ["zone=26", "proj=utm", "ellps=clrk66"]
43			proj = Projection(params)
44			self.assertEquals(proj.params, params)
45	bh	333
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	jonathan	761	# GetName()
60			self.assertEquals(proj.GetName(), _("Unknown"))
61
62			# GetParameter()
63	jonathan	714	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	bh	333
68	jonathan	761	# GetAllParameters()
69			self.assertEquals(proj.GetAllParameters(), params)
70	bh	333
71	jonathan	761	# GetName()
72			proj = Projection(params, "MyName")
73			self.assertEquals(proj.GetName(), "MyName")
74
75	bh	1798	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	bh	1793	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	jonathan	761
88	bh	1793	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	bh	1818	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	bh	1793
99	bh	1818	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	jonathan	698
105	bh	1818	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	jonathan	698
111	bh	1818	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	jonathan	698
117
118
119	bh	1821	class TestProjFileSimple:
120	bh	1813
121	bh	1821	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	bh	1813
127	bh	1821	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	bh	1813
133
134	bh	1825	class TestProjFile(unittest.TestCase, support.SubscriberMixin):
135	bh	1821
136	jonathan	698	"""Test cases for reading and writing projection files.
137			"""
138
139	bh	1821	def setUp(self):
140	bh	1825	self.clear_messages()
141	bh	1821	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	bh	1825	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	jonathan	742
149	bh	1827	def tearDown(self):
150			self.clear_messages()
151			self.proj_file.Destroy()
152
153	bh	1821	def test_add_remove(self):
154			"""Test ProjFile.Add() and ProjFile.Remove()"""
155	bh	1825	self.proj_file.Add(self.proj0)
156			self.proj_file.Add(self.proj1)
157			self.assertEquals(self.proj_file.GetProjections(),
158			[self.proj0, self.proj1])
159			self.check_messages([(self.proj0, PROJECTION_ADDED),
160			(self.proj1, PROJECTION_ADDED)])
161			self.clear_messages()
162	jonathan	742
163	bh	1825	self.proj_file.Remove(self.proj0)
164			self.assertEquals(self.proj_file.GetProjections(), [self.proj1])
165			self.check_messages([(self.proj0, PROJECTION_REMOVED)])
166
167	bh	1821	def test_remove_non_existing(self):
168			"""Test ProjFile.Remove(<proj not in projfile>)"""
169	bh	1825	self.assertRaises(ValueError, self.proj_file.Remove, self.proj0)
170			# Nothing happened, so no messages should have been sent
171			self.check_messages([])
172	jonathan	742
173	bh	1821	def test_replace(self):
174			"""Test ProjFile.Replace()"""
175	bh	1825	self.proj_file.Add(self.proj0)
176			self.proj_file.Add(self.proj1)
177			self.clear_messages()
178	jonathan	761
179	bh	1821	# Replace()
180	bh	1825	self.proj_file.Replace(self.proj0, self.proj2)
181			self.assertEquals(self.proj_file.GetProjections(),
182			[self.proj2, self.proj1])
183			self.check_messages([(self.proj0, self.proj2, PROJECTION_REPLACED)])
184	jonathan	742
185	bh	1821	def test_replace_non_existing(self):
186			"""Test ProjFile.Replace(<proj not in projfile>, <some proj>)"""
187	bh	1825	self.proj_file.Add(self.proj0)
188			self.proj_file.Add(self.proj1)
189			self.clear_messages()
190	bh	1821	self.assertRaises(ValueError,
191	bh	1825	self.proj_file.Replace, self.proj2, self.proj0)
192			# All projections should still be there
193			self.assertEquals(self.proj_file.GetProjections(),
194			[self.proj0, self.proj1])
195			# Nothing happened, so no messages should have been sent
196			self.check_messages([])
197	jonathan	742
198
199	bh	1821	class ProjFileTest(unittest.TestCase, support.FileTestMixin,
200			xmlsupport.ValidationTest):
201	jonathan	742
202	bh	1821	"""Base class for the proj file tests that read or write files"""
203	jonathan	742
204	bh	1821	def filename(self):
205			"""Return the filename for the test"""
206			return self.temp_file_name(self.id() + ".proj")
207	jonathan	742
208
209	bh	1821	class ProjFileReadTests(ProjFileTest):
210	jonathan	752
211	bh	1821	"""Test read ProjFile objects from files"""
212	jonathan	761
213	bh	1811	def test_read_non_existing_file(self):
214			"""Test read_proj_file with non-existing file"""
215	jonathan	719	self.assertRaises(IOError,
216	bh	1811	resource.read_proj_file,
217			self.temp_file_name("nonexistent.proj"))
218	jonathan	719
219	bh	1811	def test_read_unreadable_file(self):
220			"""Test read_proj_file with unreadable file
221
222			As currently written this only works on unix-like systems and
223			not e.g. on MS Windows.
224			"""
225	bh	1813	filename = self.filename()
226	jonathan	719	file = open(filename, "w")
227			file.close()
228			os.chmod(filename, 0200) # write-only
229	jonathan	1167	self.assertRaises(IOError, resource.read_proj_file, filename)
230	jonathan	719
231	bh	1811	def test_read_empty_file(self):
232			"""Test read_proj_file with empty file"""
233	bh	1813	filename = self.filename()
234	jonathan	719	file = open(filename, "w")
235			file.close()
236
237	jonathan	1167	self.assertRaises(SAXParseException, resource.read_proj_file, filename)
238	jonathan	719
239	bh	1787	def test_get_system_proj_file(self):
240			"""Test resource.get_system_proj_file()
241	jonathan	698
242	bh	1787	This is primarily to test whether the system proj file contains
243			invalid projection paramers and whether the proj file is not
244			empty
245			"""
246			projfile, warnings = resource.get_system_proj_file()
247			self.assertEquals(warnings, [])
248			self.assert_(len(projfile.GetProjections()) > 0)
249
250
251	bh	1821	class WriteProjFileTests(ProjFileTest):
252	bh	1813
253			"""Test cases for writing proj files"""
254
255			def compare_xml(self, xml1, xml2):
256			self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
257
258	bh	1818	def doTestWrite(self, projfile, expected):
259	bh	1813	filename = self.filename()
260
261	bh	1818	resource.write_proj_file(projfile)
262	bh	1813
263			file = open(filename)
264			written_contents = file.read()
265			file.close()
266			self.compare_xml(written_contents, expected)
267			self.validate_data(written_contents)
268			self.validate_data(expected)
269
270			def test_write(self):
271			"""Test write_proj_file"""
272	bh	1818	pf = ProjFile(self.filename())
273			pf.Add(Projection(['proj=tmerc', 'ellps=clrk66',
274			'lat_0=90w', 'lon_0=90w', 'k=1'],
275			"Transverse Mercator",))
276			pf.Add(Projection(["proj=tmerc",
277			"lat_0=0.000000000", "lon_0=-62.000000000",
278			"k=0.999500", "x_0=400000.000", "y_0=0.000",
279			"ellps=clrk80", "units=m"],
280			"Anguilla 1957 / British West Indies Grid",
281			epsg="200"))
282			file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
283			<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
284			<projectionlist>
285			<projection name="Transverse Mercator">
286			<parameter value="proj=tmerc"/>
287			<parameter value="ellps=clrk66"/>
288			<parameter value="lat_0=90w"/>
289			<parameter value="lon_0=90w"/>
290			<parameter value="k=1"/>
291			</projection>
292			<projection epsg="200"
293			name="Anguilla 1957 / British West Indies Grid">
294			<parameter value="proj=tmerc"/>
295			<parameter value="lat_0=0.000000000"/>
296			<parameter value="lon_0=-62.000000000"/>
297			<parameter value="k=0.999500"/>
298			<parameter value="x_0=400000.000"/>
299			<parameter value="y_0=0.000"/>
300			<parameter value="ellps=clrk80"/>
301			<parameter value="units=m"/>
302			</projection>
303			</projectionlist>
304			'''
305			self.doTestWrite(pf, file_contents)
306	bh	1813
307			def test_write_empty_file(self):
308			"""Test write empty ProjFile"""
309	bh	1818	pf = ProjFile(self.filename())
310			file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
311			<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
312			<projectionlist>
313			</projectionlist>
314			'''
315			self.doTestWrite(pf, file_contents)
316	bh	1813
317
318	bh	1818	class TestLoadingProjFile(support.FileLoadTestCase):
319
320			file_extension = ".proj"
321			file_contents = '''\
322			<?xml version="1.0" encoding="UTF-8"?>
323			<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
324			<projectionlist>
325			<projection name="Transverse Mercator">
326			<parameter value="proj=tmerc"/>
327			<parameter value="ellps=clrk66"/>
328			<parameter value="lat_0=90w"/>
329			<parameter value="lon_0=90w"/>
330			<parameter value="k=1"/>
331			</projection>
332			<projection epsg="200" name="Anguilla 1957 / British West Indies Grid">
333			<parameter value="proj=tmerc"/>
334			<parameter value="lat_0=0.000000000"/>
335			<parameter value="lon_0=-62.000000000"/>
336			<parameter value="k=0.999500"/>
337			<parameter value="x_0=400000.000"/>
338			<parameter value="y_0=0.000"/>
339			<parameter value="ellps=clrk80"/>
340			<parameter value="units=m"/>
341			</projection>
342			</projectionlist>
343			'''
344
345			def check_projection(self, proj, label, parameters):
346			"""Check the values of the proj's label and parameters"""
347			self.assertEquals(proj.Label(), label)
348			params = proj.GetAllParameters()[:]
349			params.sort()
350			self.assertEquals(params, parameters)
351
352			def test(self):
353			projfile, warnings = resource.read_proj_file(self.filename())
354			# no warnings
355			self.assertEquals(warnings, [])
356
357			# There are two projections
358			projs = projfile.GetProjections()
359			self.assertEquals(len(projs), 2)
360
361			self.check_projection(projs[0],
362			"Transverse Mercator",
363			['ellps=clrk66', 'k=1', 'lat_0=90w', 'lon_0=90w',
364			'proj=tmerc'])
365			self.check_projection(projs[1],
366			"EPSG 200 Anguilla 1957 / British West Indies Grid",
367			["ellps=clrk80", "k=0.999500",
368			"lat_0=0.000000000", "lon_0=-62.000000000",
369			"proj=tmerc", "units=m",
370			"x_0=400000.000", "y_0=0.000"])
371
372
373			class TestLoadingProjFileWithEmptyProjectionlist(support.FileLoadTestCase):
374
375			file_extension = ".proj"
376			file_contents = '''\
377			<?xml version="1.0" encoding="UTF-8"?>
378			<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
379			<projectionlist>
380			</projectionlist>
381			'''
382
383			def test(self):
384			projfile, warnings = resource.read_proj_file(self.filename())
385			# no warnings
386			self.assertEquals(warnings, [])
387
388			# There are no projections
389			self.assertEquals(len(projfile.GetProjections()), 0)
390
391
392	bh	1787	class TestProjFileWithInvalidParameters(unittest.TestCase,
393			support.FileLoadTestCase):
394
395			file_extension = ".proj"
396			file_contents = '''\
397			<?xml version="1.0" encoding="UTF-8"?>
398			<!DOCTYPE projectionlist SYSTEM "projfile.dtd">
399			<projectionlist>
400			<projection name="Universal Transverse Mercator">
401			<parameter value="proj=utm"/>
402			<parameter value="ellps=clrk66"/>
403			<!-- an invalid zone number to trigger the parameter checking
404			in the proj library -->
405			<parameter value="zone=1000"/>
406			</projection>
407			<projection name="Transverse Mercator">
408			<parameter value="proj=tmerc"/>
409			<parameter value="ellps=clrk66"/>
410			<parameter value="lat_0=90w"/>
411			<parameter value="lon_0=90w"/>
412			<parameter value="k=1"/>
413			</projection>
414			</projectionlist>
415			'''
416
417			def setUp(self):
418			support.FileLoadTestCase.setUp(self)
419
420			def test(self):
421			"""Test reading a proj file with invalid parameters"""
422			projfile, warnings = resource.read_proj_file(self.filename())
423			projs = projfile.GetProjections()
424			self.assertEquals(len(projs), 1)
425			params = projs[0].GetAllParameters()[:]
426			params.sort()
427			self.assertEquals(params, ['ellps=clrk66', 'k=1', 'lat_0=90w',
428			'lon_0=90w', 'proj=tmerc'])
429			self.assertEquals(warnings,
430			['Error in projection "Universal Transverse Mercator":'
431			' invalid UTM zone number'])
432
433
434	bh	333	if __name__ == "__main__":
435	bh	1827	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision