source: TI02-CSML/trunk/services/3rdParty/GeoTypes-0.6.0/tests/GeoTypes_Test.py @ 2194

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/services/3rdParty/GeoTypes-0.6.0/tests/GeoTypes_Test.py@2194
Revision 2194, 9.5 KB checked in by lawrence, 13 years ago (diff)

Adding various specs and 3rd party code of interest for the CSML
services development.

Line 
1
2################################################################################
3# Copyright (c) QinetiQ Plc 2003
4#
5# Licensed under the LGPL. For full license details see the LICENSE file.
6################################################################################
7
8import unittest
9import sys
10import psycopg
11import os
12
13import TestConfig
14
15if not os.environ.get('USECOVERAGE') == '1':
16##    from _Point import *
17##    from _LineSeg import *
18##    from _Box import *
19##    from _Path import *
20##    from _Polygon import *
21##    from _Circle import *
22    import GeoTypes
23
24           
25from _PsycopgInit import initialisePsycopgTypes
26
27initialisePsycopgTypes(psycopg_module=psycopg)
28
29conn = psycopg.connect('dbname=mq_test user=postgres')
30curs = conn.cursor()
31
32
33class GeoTypesPointTest(unittest.TestCase):   
34
35    def setUp(self):
36        self.curs = curs
37        self.tbl_name = "test_point_type"
38        try:
39            self.curs.execute("CREATE TABLE %s (p1 point, p2 point)" % (self.tbl_name,))
40        except:
41            conn.rollback()
42            self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
43            self.curs.execute("CREATE TABLE %s (p1 point, p2 point)" % (self.tbl_name,))
44        conn.commit()
45
46    def tearDown(self):
47        self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
48
49       
50    def testPoint(self):
51
52
53        p1 = GeoTypes.pointFromValues(1.0,2.0)
54        p2 = GeoTypes.pointFromValues(3.0,4.0)
55
56        self.curs.execute("INSERT INTO %s VALUES (%%(p1)s, %%(p2)s)"  % (self.tbl_name,),
57                          {'p1':p1, 'p2':p2})
58
59        self.curs.execute("SELECT p1,p2 FROM %s" % (self.tbl_name,))
60
61        ret = self.curs.fetchall()[0]
62
63        p3 = ret[0]
64        p4 = ret[1]
65
66        assert p3.__class__.__name__ == "Point"
67        assert p4.__class__.__name__ == "Point"
68        assert p3.getX() == 1.0
69        assert p3.getY() == 2.0
70        assert p4.getX() == 3.0
71        assert p4.getY() == 4.0
72
73class GeoTypesLineSegTest(unittest.TestCase):   
74
75    def setUp(self):
76        self.curs = curs
77        self.tbl_name = "test_lineseg_type"
78        try:
79            self.curs.execute("CREATE TABLE %s (l lseg)" % (self.tbl_name,))
80        except:
81            conn.rollback()
82            self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
83            self.curs.execute("CREATE TABLE %s (l lseg)" % (self.tbl_name,))
84        conn.commit()
85
86    def tearDown(self):
87        self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
88
89    def testLineSeg(self):
90
91        start = GeoTypes.pointFromValues(1.0,2.0)
92        end = GeoTypes.pointFromValues(3.0,4.0)
93        l = GeoTypes.lineSegFromPoints(start,end)
94
95        self.curs.execute("INSERT INTO %s VALUES (%%(l)s)" % (self.tbl_name,),
96                          {'l':l})
97
98        self.curs.execute("SELECT l FROM %s" % (self.tbl_name,))
99
100        ret = self.curs.fetchall()[0]
101
102        ol = ret[0]
103        assert ol.__class__.__name__ == "LineSeg"
104        assert ol.getStart() == start
105        assert ol.getEnd() == end
106        assert ol == l
107
108class GeoTypesBoxTest(unittest.TestCase):   
109
110    def setUp(self):
111        self.curs = curs
112        self.tbl_name = "test_box_type"
113        try:
114            self.curs.execute("CREATE TABLE %s (b box)" % (self.tbl_name,))
115        except:
116            conn.rollback()
117            self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
118            self.curs.execute("CREATE TABLE %s (b box)" % (self.tbl_name,))
119        conn.commit()
120
121    def tearDown(self):
122        self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
123
124    def testBox(self):
125
126        upper_right = GeoTypes.pointFromValues(2.0,2.0)
127        lower_left = GeoTypes.pointFromValues(1.0,1.0)
128        b = GeoTypes.boxFromPoints(upper_right,lower_left)
129
130        self.curs.execute("INSERT INTO %s VALUES (%%(b)s)" % (self.tbl_name,),
131                          {'b':b})
132
133        self.curs.execute("SELECT b FROM %s" % (self.tbl_name,))
134
135        ret = self.curs.fetchall()[0]
136
137        ol = ret[0]
138        assert ol.__class__.__name__ == "Box"
139        assert ol.getUpperRight() == upper_right
140        assert ol.getLowerLeft() == lower_left
141        assert ol == b
142
143    def testWrongCorners(self):
144        """
145        Check what happens if the upper_left and lower_right corner are
146        specified.
147
148        Postgres ourght to return the upper_right and lower_left anyway.
149        """
150
151        upper_right = GeoTypes.pointFromValues(2.0,2.0)
152        lower_left = GeoTypes.pointFromValues(1.0,1.0)
153        upper_left = GeoTypes.pointFromValues(1.0,2.0)
154        lower_right = GeoTypes.pointFromValues(2.0,1.0)
155        b = GeoTypes.boxFromPoints(upper_left,lower_right)
156               
157
158        self.curs.execute("INSERT INTO %s VALUES (%%(b)s)" % (self.tbl_name,),
159                              {'b':b})
160
161        self.curs.execute("SELECT b FROM %s" % (self.tbl_name,))
162
163        ret = self.curs.fetchall()[0]
164
165        ol = ret[0]
166
167        assert ol.__class__.__name__ == "Box"
168        assert ol.getUpperRight() == upper_right
169        assert ol.getLowerLeft() == lower_left
170        assert ol == b, ("Broken box equallity", ol, b)
171
172
173class GeoTypesPathTest(unittest.TestCase):   
174
175    def setUp(self):
176        self.curs = curs
177        self.tbl_name = "test_path_type"
178        try:
179            self.curs.execute("CREATE TABLE %s (p path)" % (self.tbl_name,))
180        except:
181            conn.rollback()
182            self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
183            self.curs.execute("CREATE TABLE %s (p path)" % (self.tbl_name,))
184        conn.commit()
185
186    def tearDown(self):
187        self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
188
189    def testPath(self):
190
191        p1 = GeoTypes.pointFromValues(1.0,2.0)
192        p2 = GeoTypes.pointFromValues(3.0,4.0)
193        p3 = GeoTypes.pointFromValues(5.0,6.0)
194        path = GeoTypes.pathFromPoints(p1,p2,p3)
195
196        self.curs.execute("INSERT INTO %s VALUES (%%(p)s)" % (self.tbl_name,),
197                          {'p':path})
198
199        self.curs.execute("SELECT p FROM %s" % (self.tbl_name,))
200
201        ret = self.curs.fetchall()[0]
202
203        op = ret[0]
204        assert op.__class__.__name__ == "Path"
205        assert op == path
206
207class GeoTypesPolygonTest(unittest.TestCase):   
208
209    def setUp(self):
210        self.curs = curs
211        self.tbl_name = "test_polygon_type"
212        try:
213            self.curs.execute("CREATE TABLE %s (p polygon)" % (self.tbl_name,))
214        except:
215            conn.rollback()
216            self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
217            self.curs.execute("CREATE TABLE %s (p polygon)" % (self.tbl_name,))
218        conn.commit()
219
220    def tearDown(self):
221        self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
222
223    def testPath(self):
224
225        p1 = GeoTypes.pointFromValues(1.0,2.0)
226        p2 = GeoTypes.pointFromValues(3.0,4.0)
227        p3 = GeoTypes.pointFromValues(5.0,6.0)
228        polygon = GeoTypes.polygonFromPoints(p1,p2,p3)
229
230        self.curs.execute("INSERT INTO %s VALUES (%%(p)s)" % (self.tbl_name,),
231                          {'p':polygon})
232
233        self.curs.execute("SELECT p FROM %s" % (self.tbl_name,))
234
235        ret = self.curs.fetchall()[0]
236
237        op = ret[0]
238        assert op.__class__.__name__ == "Polygon"
239        assert op == polygon
240
241
242class GeoTypesCircleTest(unittest.TestCase):   
243
244    def setUp(self):
245        self.curs = curs
246        self.tbl_name = "test_circle_type"
247        try:
248            self.curs.execute("CREATE TABLE %s (c circle)" % (self.tbl_name,))
249        except:
250            conn.rollback()
251            self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
252            self.curs.execute("CREATE TABLE %s (c circle)" % (self.tbl_name,))
253        conn.commit()
254
255    def tearDown(self):
256        self.curs.execute("DROP TABLE %s"  % (self.tbl_name,))
257
258    def testCircle(self):
259
260        centre = GeoTypes.pointFromValues(1.0,1.0)
261        radius = 5
262        c = GeoTypes.circleFromCentreAndRadius(centre,radius)
263
264        self.curs.execute("INSERT INTO %s VALUES (%%(c)s)" % (self.tbl_name,),
265                          {'c':c})
266
267        self.curs.execute("SELECT c FROM %s" % (self.tbl_name,))
268
269        ret = self.curs.fetchall()[0]
270
271        oc = ret[0]
272        assert oc.__class__.__name__ == "Circle"
273        assert oc.getCentre() == centre
274        assert oc.getRadius() == radius
275        assert oc == c
276
277    def testzzz_CoverageAssertion(self):
278        try:
279            coverage.stop()
280        except:
281            return 1
282       
283        x = coverage.analysis(GeoTypes)
284        assert x[2]==[], "Coverage is less than 100%"
285
286def testSuite():
287    return unittest.TestSuite((
288        unittest.makeSuite(GeoTypesPointTest,'test'),
289        unittest.makeSuite(GeoTypesLineSegTest,'test'),
290        unittest.makeSuite(GeoTypesBoxTest,'test'),
291        unittest.makeSuite(GeoTypesPathTest,'test'),
292        unittest.makeSuite(GeoTypesPolygonTest,'test'),
293        unittest.makeSuite(GeoTypesCircleTest,'test')
294        ))
295
296if __name__ == "__main__":
297    import os
298    if os.environ.get('USECOVERAGE') == '1':
299        try:
300            import coverage
301            coverage.erase()
302            coverage.start()
303            COVERAGE = 1
304            import GeoTypes         
305
306        except:
307            print "Error setting up coverage checking"
308            COVERAGE = 0
309    else:
310        COVERAGE = 0
311
312    if os.environ.get('USEPYCHECK') == '1':
313        try:
314            import pychecker.checker
315        except:
316            print "Pychecker not installed on this machine"
317
318
319    unittest.TextTestRunner().run(testSuite())
320
321    if COVERAGE:
322        coverage.stop()
323        x = coverage.analysis(GeoTypes)
324        print "\n"
325        coverage.report(GeoTypes)
326
327
Note: See TracBrowser for help on using the repository browser.