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 support
support.initthuban()

from Thuban import _
from Thuban.Model.proj import Projection, ProjFile

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


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

        #
        # file doesn't exist
        #
        self.assertRaises(IOError,
            resource.read_proj_file, 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.read_proj_file, 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.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)

    def doTestRead(self, data, input):

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

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