WIP-pyshapelib-bramz/test/test_proj.py

# Copyright (c) 2002 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 support
support.initthuban()

from Thuban.Model.proj import Projection, ProjFile

import Thuban.Model.resource as resource

from test_save 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"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.assertEquals(proj.params, ["zone=26", "proj=utm", "ellps=clrk66"])

        # 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)

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


sample_projfile = '''\
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE projfile SYSTEM "thuban.dtd">
<projectionlist>
    <projection name="Transverse Mercartor">
        <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 Mercartor">
        <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 Mercartor">
        <parameter value="proj=utm"/>
        <parameter value="ellps=clrk66"/>
        <parameter value="zone=1"/>
    </projection>
</projectionlist>
'''

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

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

sample_projfile_data2 = []

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

    """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"])

        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, 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)

    def testRead(self):
        """Test ReadProjFile"""

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

        #
        # file doesn't exist
        #
        self.assertRaises(IOError,
            resource.ReadProjFile, self.temp_file_name("nonexistent.proj"))

        #
        # file isn't readable
        #
        filename = self.temp_file_name("projfile.proj")
        file = open(filename, "w")
        file.close()
        os.chmod(filename, 0200) # write-only
        self.assertRaises(IOError, resource.ReadProjFile, filename)
        os.chmod(filename, 0600) # read/write so we reuse the file

        #
        # file has invalid XML (or none at all)
        #
        filename = self.temp_file_name("projfile.proj")
        file = open(filename, "w")
        file.close()

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

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

        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.WriteProjFile(pf)

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

    def doTestRead(self, data, input):

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

        pf = resource.ReadProjFile(filename)

        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])


if __name__ == "__main__":
    unittest.main()
1	bh	333	# Copyright (c) 2002 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	jonathan	719	import os
18	bh	333
19			import support
20			support.initthuban()
21
22	jonathan	698	from Thuban.Model.proj import Projection, ProjFile
23	bh	333
24	jonathan	698	import Thuban.Model.resource as resource
25	bh	333
26	jonathan	698	from test_save import sax_eventlist
27
28	jonathan	719	from xml.sax import SAXParseException
29	jonathan	698
30	jonathan	719
31	bh	333	class TestProjection(unittest.TestCase, support.FloatComparisonMixin):
32
33			"""Test cases for the Thuban-specific Projection class
34			"""
35
36			def test(self):
37			"""Test Projection"""
38			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
39			self.assertEquals(proj.params, ["zone=26", "proj=utm", "ellps=clrk66"])
40
41			# It's not clear whether this value is really the correct one
42			# but a test failure here probably still means a bug somewhere
43			self.assertFloatSeqEqual(proj.Forward(0, 0),
44			[3623101.8103431347, 0.0],
45			epsilon = 1e-5)
46			self.assertFloatSeqEqual(proj.Inverse(3623101.8103431347, 0.0),
47			[-0.00065775699878736467, 0])
48
49			self.assertFloatSeqEqual(proj.ForwardBBox((0, 0, 2, 2)),
50			(3620891.3077618643, 0.0,
51			3875381.8535437919, 252962.10480170773),
52			epsilon = 1e-5)
53
54	jonathan	714	self.assertEquals(proj.GetParameter("zone"), "26")
55			self.assertEquals(proj.GetParameter("proj"), "utm")
56			self.assertEquals(proj.GetParameter("ellps"), "clrk66")
57			self.assertEquals(proj.GetParameter("hallo"), "")
58	bh	333
59
60	jonathan	698	sample_projfile = '''\
61			<?xml version="1.0" encoding="UTF-8"?>
62			<!DOCTYPE projfile SYSTEM "thuban.dtd">
63			<projectionlist>
64			<projection name="Transverse Mercartor">
65			<parameter value="proj=tmerc"/>
66			<parameter value="ellps=clrk66"/>
67			<parameter value="lat_0=90w"/>
68			<parameter value="lon_0=90w"/>
69			<parameter value="k=1"/>
70			</projection>
71			<projection name="Transverse Mercartor">
72			<parameter value="proj=tmerc"/>
73			<parameter value="ellps=clrk66"/>
74			<parameter value="lat_0=30w"/>
75			<parameter value="lon_0=30w"/>
76			<parameter value="k=1"/>
77			</projection>
78			<projection name="Universal Transverse Mercartor">
79			<parameter value="proj=utm"/>
80			<parameter value="ellps=clrk66"/>
81			<parameter value="zone=1"/>
82			</projection>
83			</projectionlist>
84			'''
85
86			sample_projfile_data = [("Transverse Mercartor", ["proj=tmerc",
87			"ellps=clrk66",
88			"lat_0=90w",
89			"lon_0=90w",
90			"k=1"]),
91			("Transverse Mercartor", ["proj=tmerc",
92			"ellps=clrk66",
93			"lat_0=30w",
94			"lon_0=30w",
95			"k=1"]),
96			("Universal Transverse Mercartor", ["proj=utm",
97			"ellps=clrk66",
98			"zone=1"])]
99
100			sample_projfile2 = '''\
101			<?xml version="1.0" encoding="UTF-8"?>
102			<!DOCTYPE projfile SYSTEM "thuban.dtd">
103			<projectionlist>
104			</projectionlist>
105			'''
106
107			sample_projfile_data2 = []
108
109			class TestProjFile(unittest.TestCase, support.FileTestMixin):
110
111			"""Test cases for reading and writing projection files.
112			"""
113
114			def compare_xml(self, xml1, xml2):
115			self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
116
117	jonathan	742	def test(self):
118			"""Test ProjFile"""
119
120			proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
121			proj1 = Projection(["proj=utm", "ellps=clrk66"])
122			proj2 = Projection(["proj=lcc", "ellps=clrk66"])
123
124			eq = self.assertEquals
125
126			#
127			# __init__()
128			# GetFilename()
129			# SetFilename()
130			#
131			for name in ["", "hello_world"]:
132			projFile = ProjFile(name)
133			eq(projFile.GetFilename(), name)
134
135			projFile.SetFilename("XXX")
136			projFile.SetFilename(name)
137			eq(projFile.GetFilename(), name)
138
139			# initial number of projections should be 0
140			eq(len(projFile.GetProjections()), 0)
141
142			#
143			# Add()
144			# Remove()
145			#
146			projFile.Add(proj0)
147			eq(len(projFile.GetProjections()), 1)
148			projFile.Remove(proj0)
149			eq(len(projFile.GetProjections()), 0)
150
151			# try to remove something that doesn't exist
152			self.assertRaises(ValueError, projFile.Remove, proj0)
153
154			projFile.Add(proj0)
155			projFile.Add(proj1)
156			projFile.Add(proj2)
157			eq(len(projFile.GetProjections()), 3)
158
159			# GetProjections() -- tests order
160			projs = projFile.GetProjections()
161			eq(projs[0], proj0)
162			eq(projs[1], proj1)
163			eq(projs[2], proj2)
164
165	jonathan	698	def testRead(self):
166			"""Test ReadProjFile"""
167
168			self.doTestRead(sample_projfile_data, sample_projfile)
169			self.doTestRead(sample_projfile_data2, sample_projfile2)
170
171	jonathan	719	#
172			# file doesn't exist
173			#
174			self.assertRaises(IOError,
175			resource.ReadProjFile, self.temp_file_name("nonexistent.proj"))
176
177			#
178			# file isn't readable
179			#
180			filename = self.temp_file_name("projfile.proj")
181			file = open(filename, "w")
182			file.close()
183			os.chmod(filename, 0200) # write-only
184			self.assertRaises(IOError, resource.ReadProjFile, filename)
185			os.chmod(filename, 0600) # read/write so we reuse the file
186
187			#
188			# file has invalid XML (or none at all)
189			#
190			filename = self.temp_file_name("projfile.proj")
191			file = open(filename, "w")
192			file.close()
193
194			self.assertRaises(SAXParseException, resource.ReadProjFile, filename)
195
196	jonathan	698	def testWrite(self):
197			"""Test WriteProjFile"""
198
199			self.doTestWrite(sample_projfile_data, sample_projfile)
200			self.doTestWrite(sample_projfile_data2, sample_projfile2)
201
202			def doTestWrite(self, data, expected):
203
204			filename = self.temp_file_name("projfile.proj")
205
206			pf = ProjFile(filename)
207			for proj in data:
208			pf.Add(Projection(proj[1], proj[0]))
209
210			resource.WriteProjFile(pf)
211
212			file = open(filename)
213			written_contents = file.read()
214			file.close()
215			self.compare_xml(written_contents, expected)
216
217			def doTestRead(self, data, input):
218
219			filename = self.temp_file_name("projfile.proj")
220			file = open(filename, "w")
221			file.write(input)
222			file.close()
223
224			pf = resource.ReadProjFile(filename)
225
226			eq = self.assertEquals
227
228	jonathan	742	eq(pf.GetFilename(), filename)
229	jonathan	698
230			for proj, d in zip(pf.GetProjections(), data):
231			eq(proj.GetName(), d[0])
232	jonathan	714	for param in proj.GetAllParameters():
233	jonathan	698	self.assert_(param in d[1])
234
235
236	bh	333	if __name__ == "__main__":
237			unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision