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 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 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.filename()
        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.filename()
        file = open(filename, "w")
        file.close()

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

    def doTestRead(self, data, input):

        filename = self.filename()
        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 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, data, expected):
        filename = self.filename()

        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 test_write(self):
        """Test write_proj_file"""
        self.doTestWrite(sample_projfile_data, sample_projfile)

    def test_write_empty_file(self):
        """Test write empty ProjFile"""
        self.doTestWrite(sample_projfile_data2, sample_projfile2)


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