/[thuban]/branches/WIP-pyshapelib-bramz/test/test_proj.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/test/test_proj.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1811 by bh, Mon Oct 13 13:36:34 2003 UTC revision 2696 by bernhard, Sun Sep 17 23:19:21 2006 UTC
# Line 14  __version__ = "$Revision$" Line 14  __version__ = "$Revision$"
14  # $Id$  # $Id$
15    
16  import unittest  import unittest
17    import locale
18  import os  import os
19    
20    import localessupport
21  import xmlsupport  import xmlsupport
22  import support  import support
23  support.initthuban()  support.initthuban()
# Line 23  support.initthuban() Line 25  support.initthuban()
25  from Thuban import _  from Thuban import _
26  from Thuban.Model.proj import Projection, ProjFile, \  from Thuban.Model.proj import Projection, ProjFile, \
27       PROJ_UNITS_METERS, PROJ_UNITS_DEGREES       PROJ_UNITS_METERS, PROJ_UNITS_DEGREES
28    from Thuban.Model.messages import PROJECTION_ADDED, PROJECTION_REMOVED, \
29         PROJECTION_REPLACED
30  import Thuban.Model.resource as resource  import Thuban.Model.resource as resource
31    
32  from xmlsupport import sax_eventlist  from xmlsupport import sax_eventlist
# Line 54  class TestProjection(unittest.TestCase, Line 57  class TestProjection(unittest.TestCase,
57                                   (3620891.3077618643, 0.0,                                   (3620891.3077618643, 0.0,
58                                    3875381.8535437919, 252962.10480170773),                                    3875381.8535437919, 252962.10480170773),
59                                   epsilon = 1e-5)                                   epsilon = 1e-5)
60            self.assertFloatSeqEqual(proj.InverseBBox((3620891.3077618643, 0.0,
61                                                       3875381.8535437919,
62                                                       252962.10480170773)),
63                                     (-0.018341599754143501, 0.0,
64                                      2.017992992681688, 2.0377390677846736),
65                                     epsilon = 1e-5)
66    
67          # GetName()          # GetName()
68          self.assertEquals(proj.GetName(), _("Unknown"))          self.assertEquals(proj.GetName(), _("Unknown"))
# Line 79  class TestProjection(unittest.TestCase, Line 88  class TestProjection(unittest.TestCase,
88          self.assertEquals(proj.GetParameter("south"), "south")          self.assertEquals(proj.GetParameter("south"), "south")
89    
90      def test_get_projection_units_geo(self):      def test_get_projection_units_geo(self):
91          """Test Projection.GetProjectedUnits() for geographic projection"""          """Test Projection.GetProjectedUnits() for geographic projection.
92            Test for the alias 'longlat' as well.
93            """
94          proj = Projection(["proj=latlong", "to_meter=0.017453292519943295",          proj = Projection(["proj=latlong", "to_meter=0.017453292519943295",
95                             "ellps=clrk66"])                             "ellps=clrk66"])
96          self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_DEGREES)          self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_DEGREES)
97            proj = Projection(["proj=longlat", "to_meter=0.017453292519943295",
98                               "ellps=clrk66"])
99            self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_DEGREES)
100    
101        def test_lc_numeric_robustness(self):
102            """Test if an LC_NUMERIC local with comma as decimal_point will work.
103    
104            Some versions of proj are not robust against this.
105            Starting with Python 2.4 there is a different behaviour when
106            calling C extensions and now they will see changes locales settings
107            which might tickle the bug in proj.
108            """
109            params = ["proj=latlong", "to_meter=0.01745", "ellps=clrk66"]
110    
111            oldlocale = localessupport.setdecimalcommalocale()
112            if oldlocale == None:
113                raise support.SkipTest(
114                        "No locale with comma as decimal_point found.")
115    
116            proj = Projection(params)
117            result1 =  proj.Forward(1,1)
118    
119            locale.setlocale(locale.LC_NUMERIC, "C")
120            proj = Projection(params)
121            result2= proj.Forward(1,1)
122    
123            locale.setlocale(locale.LC_NUMERIC, oldlocale)
124            self.assertFloatSeqEqual(result1, result2, epsilon = 1e-5 )
125    
126      def test_get_projection_units_normal(self):      def test_get_projection_units_normal(self):
127          """Test Projection.GetProjectedUnits() for normal projection"""          """Test Projection.GetProjectedUnits() for normal projection"""
128          proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])          proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
129          self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_METERS)          self.assertEquals(proj.GetProjectedUnits(), PROJ_UNITS_METERS)
130    
131        def test_label(self):
132            """Test Projection.Label() without epsg"""
133            proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
134                               name = "My Projection")
135            self.assertEquals(proj.Label(), "My Projection")
136    
137        def test_label_epsg(self):
138            """Test Projection.Label() with epsg"""
139            proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
140                               name = "My Projection", epsg="42")
141            self.assertEquals(proj.Label(), "EPSG    42 My Projection")
142    
143        def test_epsgcode_for_non_epsg_projection(self):
144            """Test Projection.EPSGCode() without epsg"""
145            proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
146                               name = "My Projection")
147            self.assertEquals(proj.EPSGCode(), None)
148    
149        def test_epsgcode_for_real_epsg_projection(self):
150            """Test Projection.EPSGCode() with epsg"""
151            proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"],
152                               name = "My Projection", epsg="42")
153            self.assertEquals(proj.EPSGCode(), "42")
154    
 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>  
 '''  
155    
 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"])]  
156    
157  sample_projfile2 = '''\  class TestProjFileSimple:
158  <?xml version="1.0" encoding="UTF-8"?>  
159  <!DOCTYPE projectionlist SYSTEM "projfile.dtd">      def test_init(self):
160  <projectionlist>          """Test ProjFile coinstructor"""
161  </projectionlist>          proj_file = ProjFile("some_filename")
162  '''          self.assertEquals(proj_file.GetFilename(), "some_filename")
163            self.assertEquals(len(proj_file.GetProjections()), 0)
164    
165        def test_set_filename(self):
166            """Test ProjFile.SetFilename()"""
167            proj_file = ProjFile("some_filename")
168            proj.SetFilename("other_name")
169            self.assertEquals(proj_file.GetFilename(), "other_name")
170    
171    
172    class TestProjFile(unittest.TestCase, support.SubscriberMixin):
173    
174        """Test cases for ProjFile objects"""
175    
176        def setUp(self):
177            self.clear_messages()
178            self.proj0 = Projection(["proj=tmerc", "ellps=clrk66"])
179            self.proj1 = Projection(["proj=utm", "ellps=clrk66"])
180            self.proj2 = Projection(["proj=lcc", "ellps=clrk66",
181                                     "lat_1=0", "lat_2=20"])
182            self.proj_file = ProjFile("some_filename")
183            for msg in [PROJECTION_ADDED, PROJECTION_REMOVED, PROJECTION_REPLACED]:
184                self.proj_file.Subscribe(msg, self.subscribe_with_params, msg)
185    
186        def tearDown(self):
187            self.clear_messages()
188            self.proj_file.Destroy()
189    
190        def test_add_remove(self):
191            """Test ProjFile.Add() and ProjFile.Remove()"""
192            self.proj_file.Add(self.proj0)
193            self.proj_file.Add(self.proj1)
194            self.assertEquals(self.proj_file.GetProjections(),
195                              [self.proj0, self.proj1])
196            self.check_messages([(self.proj0, PROJECTION_ADDED),
197                                 (self.proj1, PROJECTION_ADDED)])
198            self.clear_messages()
199    
200            self.proj_file.Remove(self.proj0)
201            self.assertEquals(self.proj_file.GetProjections(), [self.proj1])
202            self.check_messages([(self.proj0, PROJECTION_REMOVED)])
203    
204        def test_remove_non_existing(self):
205            """Test ProjFile.Remove(<proj not in projfile>)"""
206            self.assertRaises(ValueError, self.proj_file.Remove, self.proj0)
207            # Nothing happened, so no messages should have been sent
208            self.check_messages([])
209    
210        def test_replace(self):
211            """Test ProjFile.Replace()"""
212            self.proj_file.Add(self.proj0)
213            self.proj_file.Add(self.proj1)
214            self.clear_messages()
215    
216            # Replace()
217            self.proj_file.Replace(self.proj0, self.proj2)
218            self.assertEquals(self.proj_file.GetProjections(),
219                              [self.proj2, self.proj1])
220            self.check_messages([(self.proj0, self.proj2, PROJECTION_REPLACED)])
221    
222        def test_replace_non_existing(self):
223            """Test ProjFile.Replace(<proj not in projfile>, <some proj>)"""
224            self.proj_file.Add(self.proj0)
225            self.proj_file.Add(self.proj1)
226            self.clear_messages()
227            self.assertRaises(ValueError,
228                              self.proj_file.Replace, self.proj2, self.proj0)
229            # All projections should still be there
230            self.assertEquals(self.proj_file.GetProjections(),
231                              [self.proj0, self.proj1])
232            # Nothing happened, so no messages should have been sent
233            self.check_messages([])
234    
 sample_projfile_data2 = []  
235    
236  class TestProjFile(unittest.TestCase, support.FileTestMixin,  class ProjFileTest(unittest.TestCase, support.FileTestMixin,
237                     xmlsupport.ValidationTest):                     xmlsupport.ValidationTest):
238    
239      """Test cases for reading and writing projection files.      """Base class for the proj file tests that read or write files"""
     """  
240    
241      def compare_xml(self, xml1, xml2):      def filename(self):
242          self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))          """Return the filename for the test"""
243            return self.temp_file_name(self.id() + ".proj")
244    
     def test(self):  
         """Test ProjFile"""  
245    
246          proj0 = Projection(["proj=tmerc", "ellps=clrk66"])  class ProjFileReadTests(ProjFileTest):
         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)  
247    
248          projFile.Remove(proj2)      """Test read ProjFile objects from files
         projFile.Remove(proj1)  
249    
250          # Replace()      The files only cover error handling and the system projection file.
251          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)  
252    
253      def test_read_non_existing_file(self):      def test_read_non_existing_file(self):
254          """Test read_proj_file with non-existing file"""          """Test read_proj_file with non-existing file"""
# Line 228  class TestProjFile(unittest.TestCase, su Line 262  class TestProjFile(unittest.TestCase, su
262          As currently written this only works on unix-like systems and          As currently written this only works on unix-like systems and
263          not e.g. on MS Windows.          not e.g. on MS Windows.
264          """          """
265          filename = self.temp_file_name("projfile.proj")          if os.name != "posix":
266                raise support.SkipTest("Test only works on posix systems")
267            filename = self.filename()
268          file = open(filename, "w")          file = open(filename, "w")
269          file.close()          file.close()
270          os.chmod(filename, 0200) # write-only          os.chmod(filename, 0200) # write-only
271          self.assertRaises(IOError, resource.read_proj_file, filename)          self.assertRaises(IOError, resource.read_proj_file, filename)
         os.chmod(filename, 0600) # read/write so we reuse the file  
272    
273      def test_read_empty_file(self):      def test_read_empty_file(self):
274          """Test read_proj_file with empty file"""          """Test read_proj_file with empty file"""
275          filename = self.temp_file_name("projfile.proj")          filename = self.filename()
276          file = open(filename, "w")          file = open(filename, "w")
277          file.close()          file.close()
278    
279          self.assertRaises(SAXParseException, resource.read_proj_file, filename)          self.assertRaises(SAXParseException, resource.read_proj_file, filename)
280    
281      def testWrite(self):      def test_get_system_proj_file(self):
282          """Test write_proj_file"""          """Test resource.get_system_proj_file(DEFAULT_PROJ_FILE)
283    
284          self.doTestWrite(sample_projfile_data, sample_projfile)          This is primarily to test whether the system proj file contains
285          self.doTestWrite(sample_projfile_data2, sample_projfile2)          invalid projection paramers and whether the proj file is not
286            empty
287            """
288            projfile, warnings\
289                      = resource.get_system_proj_file(resource.DEFAULT_PROJ_FILE)
290            self.assertEquals(warnings, [])
291            self.assert_(len(projfile.GetProjections()) > 0)
292    
293            # see whether it got cached and we get the same projfile object
294            # when we read the file again
295            projfile2, warnings \
296                       = resource.get_system_proj_file(resource.DEFAULT_PROJ_FILE)
297            self.assert_(projfile is projfile2)
298    
299    
300    class WriteProjFileTests(ProjFileTest):
301    
302      def doTestWrite(self, data, expected):      """Test cases for writing proj files"""
303    
304          filename = self.temp_file_name("projfile.proj")      def compare_xml(self, xml1, xml2):
305            self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
306    
307          pf = ProjFile(filename)      def doTestWrite(self, projfile, expected):
308          for proj in data:          filename = self.filename()
             pf.Add(Projection(proj[1], proj[0]))  
309    
310          resource.write_proj_file(pf)          resource.write_proj_file(projfile)
311    
312          file = open(filename)          file = open(filename)
313          written_contents = file.read()          written_contents = file.read()
# Line 266  class TestProjFile(unittest.TestCase, su Line 316  class TestProjFile(unittest.TestCase, su
316          self.validate_data(written_contents)          self.validate_data(written_contents)
317          self.validate_data(expected)          self.validate_data(expected)
318    
319      def doTestRead(self, data, input):      def test_write(self):
320            """Test write_proj_file"""
321            pf = ProjFile(self.filename())
322            pf.Add(Projection(['proj=tmerc', 'ellps=clrk66',
323                               'lat_0=90w', 'lon_0=90w', 'k=1'],
324                              "Transverse Mercator",))
325            pf.Add(Projection(["proj=tmerc",
326                               "lat_0=0.000000000", "lon_0=-62.000000000",
327                               "k=0.999500", "x_0=400000.000", "y_0=0.000",
328                               "ellps=clrk80", "units=m"],
329                              "Anguilla 1957 / British West Indies Grid",
330                              epsg="200"))
331            file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
332            <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
333            <projectionlist>
334                <projection name="Transverse Mercator">
335                    <parameter value="proj=tmerc"/>
336                    <parameter value="ellps=clrk66"/>
337                    <parameter value="lat_0=90w"/>
338                    <parameter value="lon_0=90w"/>
339                    <parameter value="k=1"/>
340                </projection>
341                <projection epsg="200"
342                            name="Anguilla 1957 / British West Indies Grid">
343                    <parameter value="proj=tmerc"/>
344                    <parameter value="lat_0=0.000000000"/>
345                    <parameter value="lon_0=-62.000000000"/>
346                    <parameter value="k=0.999500"/>
347                    <parameter value="x_0=400000.000"/>
348                    <parameter value="y_0=0.000"/>
349                    <parameter value="ellps=clrk80"/>
350                    <parameter value="units=m"/>
351                </projection>
352            </projectionlist>
353            '''
354            self.doTestWrite(pf, file_contents)
355    
356        def test_write_empty_file(self):
357            """Test write empty ProjFile"""
358            pf = ProjFile(self.filename())
359            file_contents = '''<?xml version="1.0" encoding="UTF-8"?>
360            <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
361            <projectionlist>
362            </projectionlist>
363            '''
364            self.doTestWrite(pf, file_contents)
365    
366    
367    class ProjFileLoadTestCase(support.FileLoadTestCase):
368    
369        """Base class for the test cases that read specific test files"""
370    
371        file_extension = ".proj"
372    
373        def tearDown(self):
374            """Clear the cache explicitly"""
375            resource.clear_proj_file_cache()
376    
         filename = self.temp_file_name("projfile.proj")  
         file = open(filename, "w")  
         file.write(input)  
         file.close()  
377    
378          pf, warnings = resource.read_proj_file(filename)  class TestLoadingProjFile(ProjFileLoadTestCase):
379    
380        file_contents = '''\
381    <?xml version="1.0" encoding="UTF-8"?>
382    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
383    <projectionlist>
384        <projection name="Transverse Mercator">
385            <parameter value="proj=tmerc"/>
386            <parameter value="ellps=clrk66"/>
387            <parameter value="lat_0=90w"/>
388            <parameter value="lon_0=90w"/>
389            <parameter value="k=1"/>
390        </projection>
391        <projection epsg="200" name="Anguilla 1957 / British West Indies Grid">
392            <parameter value="proj=tmerc"/>
393            <parameter value="lat_0=0.000000000"/>
394            <parameter value="lon_0=-62.000000000"/>
395            <parameter value="k=0.999500"/>
396            <parameter value="x_0=400000.000"/>
397            <parameter value="y_0=0.000"/>
398            <parameter value="ellps=clrk80"/>
399            <parameter value="units=m"/>
400        </projection>
401    </projectionlist>
402    '''
403    
404        def check_projection(self, proj, label, parameters):
405            """Check the values of the proj's label and parameters"""
406            self.assertEquals(proj.Label(), label)
407            params = proj.GetAllParameters()[:]
408            params.sort()
409            self.assertEquals(params, parameters)
410    
411        def test(self):
412            projfile, warnings = resource.read_proj_file(self.filename())
413            # no warnings
414          self.assertEquals(warnings, [])          self.assertEquals(warnings, [])
415    
416          eq = self.assertEquals          # There are two projections
417            projs = projfile.GetProjections()
418            self.assertEquals(len(projs), 2)
419    
420          eq(pf.GetFilename(), filename)          self.check_projection(projs[0],
421                                  "Transverse Mercator",
422                                  ['ellps=clrk66', 'k=1', 'lat_0=90w', 'lon_0=90w',
423                                   'proj=tmerc'])
424            self.check_projection(projs[1],
425                             "EPSG   200 Anguilla 1957 / British West Indies Grid",
426                                  ["ellps=clrk80", "k=0.999500",
427                                   "lat_0=0.000000000", "lon_0=-62.000000000",
428                                   "proj=tmerc", "units=m",
429                                   "x_0=400000.000", "y_0=0.000"])
430    
431          for proj, d in zip(pf.GetProjections(), data):      def test_caching(self):
432              eq(proj.GetName(), d[0])          # test whether the projfile cache works
433              for param in proj.GetAllParameters():          projfile, warnings = resource.read_proj_file(self.filename())
434                  self.assert_(param in d[1])          projfile2, warnings = resource.read_proj_file(self.filename())
435    
436      def test_get_system_proj_file(self):          # Both projfiles should be the same object
437          """Test resource.get_system_proj_file()          self.assert_(projfile2 is projfile)
438    
439          This is primarily to test whether the system proj file contains          # If we clear the cache we should get a new one.
440          invalid projection paramers and whether the proj file is not          resource.clear_proj_file_cache()
441          empty          projfile3, warnings = resource.read_proj_file(self.filename())
442          """          self.assert_(projfile3 is not projfile)
443          projfile, warnings = resource.get_system_proj_file()  
444    
445    class TestLoadingProjFileWithEmptyProjectionlist(ProjFileLoadTestCase):
446    
447        file_contents = '''\
448    <?xml version="1.0" encoding="UTF-8"?>
449    <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
450    <projectionlist>
451    </projectionlist>
452    '''
453    
454        def test(self):
455            projfile, warnings = resource.read_proj_file(self.filename())
456            # no warnings
457          self.assertEquals(warnings, [])          self.assertEquals(warnings, [])
         self.assert_(len(projfile.GetProjections()) > 0)  
458    
459            # There are no projections
460            self.assertEquals(len(projfile.GetProjections()), 0)
461    
 class TestProjFileWithInvalidParameters(unittest.TestCase,  
                                         support.FileLoadTestCase):  
462    
463      file_extension = ".proj"  class TestProjFileWithInvalidParameters(ProjFileLoadTestCase):
464    
465      file_contents = '''\      file_contents = '''\
466  <?xml version="1.0" encoding="UTF-8"?>  <?xml version="1.0" encoding="UTF-8"?>
467  <!DOCTYPE projectionlist SYSTEM "projfile.dtd">  <!DOCTYPE projectionlist SYSTEM "projfile.dtd">
# Line 339  class TestProjFileWithInvalidParameters( Line 500  class TestProjFileWithInvalidParameters(
500                          ' invalid UTM zone number'])                          ' invalid UTM zone number'])
501    
502    
   
503  if __name__ == "__main__":  if __name__ == "__main__":
504      unittest.main()      support.run_tests()
Legend:
Removed from v.1811  
changed lines
  Added in v.2696
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26