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

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/services/3rdParty/GeoTypes-0.6.0/tests/OGGeoTypes_Test.py@2194
Revision 2194, 24.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, traceback
10import psycopg
11import os
12
13import TestConfig
14
15if not os.environ.get('USECOVERAGE') == '1':
16    import GeoTypes
17
18           
19from _PsycopgInit import initialisePsycopgTypes
20
21dbname='mq_test'
22
23initialisePsycopgTypes(psycopg_module=psycopg,connect_string='dbname=%s user=postgres' % (dbname,),
24                       register_opengis_types=1)
25
26conn = psycopg.connect('dbname=%s user=postgres' % (dbname,))
27curs = conn.cursor()
28
29class OGGeoTypesTestBase(unittest.TestCase):
30
31    def _setUp(self,type):
32        self.curs = curs
33        self.tbl_name_2d = "test_og_point_type2d"
34        self.tbl_name_3d = "test_og_point_type3d"
35       
36        try:
37            conn.rollback()
38            self.curs.execute("CREATE TABLE %s (dummy int)" % (self.tbl_name_2d,))
39            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p1', 128, '%s', 2 )" % (dbname,self.tbl_name_2d,type))
40            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p2', 128, '%s', 2 )" % (dbname,self.tbl_name_2d,type))
41            self.curs.execute("CREATE TABLE %s (dummy int)" % (self.tbl_name_3d,))
42            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p1', 128, '%s', 3 )" % (dbname,self.tbl_name_3d,type))
43            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p2', 128, '%s', 3 )" % (dbname,self.tbl_name_3d,type))
44        except:
45##            print "Exception in setUp code1:"
46##            print '-'*60
47##            traceback.print_exc(file=sys.stdout)
48##            print '-'*60
49            conn.rollback()
50            try:
51                self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p1' )" % (dbname,self.tbl_name_2d,))
52                self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p2' )" % (dbname,self.tbl_name_2d,))
53                self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p1' )" % (dbname,self.tbl_name_3d,))
54                self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p2' )" % (dbname,self.tbl_name_3d,))
55            except:
56                print "Exception in setUp code2:"
57                print '-'*60
58                traceback.print_exc(file=sys.stdout)
59                print '-'*60
60                conn.rollback()
61               
62            self.curs.execute("DROP TABLE %s"  % (self.tbl_name_2d,))
63            self.curs.execute("DROP TABLE %s"  % (self.tbl_name_3d,))
64            conn.commit()
65            self.curs.execute("CREATE TABLE %s (dummy int)" % (self.tbl_name_2d,))
66            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p1', 128, '%s', 2 )" % (dbname,self.tbl_name_2d,type))
67            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p2', 128, '%s', 2 )" % (dbname,self.tbl_name_2d,type))
68            self.curs.execute("CREATE TABLE %s (dummy int)" % (self.tbl_name_3d,))
69            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p1', 128, '%s', 3 )" % (dbname,self.tbl_name_3d,type))
70            self.curs.execute("SELECT AddGeometryColumn('%s', '%s', 'p2', 128, '%s', 3 )" % (dbname,self.tbl_name_3d,type))
71        conn.commit()
72
73    def _tearDown(self):
74        conn.rollback()
75        try:
76            self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p1' )" % (dbname,self.tbl_name_2d,))
77            self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p2' )" % (dbname,self.tbl_name_2d,))
78            self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p1' )" % (dbname,self.tbl_name_3d,))
79            self.curs.execute("SELECT DropGeometryColumn('%s', '%s', 'p2' )" % (dbname,self.tbl_name_3d,))
80        except:
81            print "Exception in tearDown code:"
82            print '-'*60
83            traceback.print_exc(file=sys.stdout)
84            print '-'*60
85            conn.rollback()
86        self.curs.execute("DROP TABLE %s"  % (self.tbl_name_2d,))
87        self.curs.execute("DROP TABLE %s"  % (self.tbl_name_3d,))
88        conn.commit()
89
90    def _sub_test2dWKB(self,p1,p2):
91        self.curs.execute("INSERT INTO %s (p1,p2) VALUES (%%(p1)s, %%(p2)s)"  % (self.tbl_name_2d,),
92                          {'p1':p1, 'p2':p2})
93
94
95        self.curs.execute("""DECLARE zot BINARY CURSOR FOR SELECT p1,p2 FROM %s
96                                           FOR READ ONLY""" % (self.tbl_name_2d,))
97        self.curs.execute("""FETCH ALL FROM zot""")
98
99        raw = self.curs.fetchall()
100
101        conn.commit()
102
103        return raw
104
105
106    def _sub_test3dWKB(self,p1,p2):
107        self.curs.execute("INSERT INTO %s (p1,p2) VALUES (%%(p1)s, %%(p2)s)"  % (self.tbl_name_3d,),
108                          {'p1':p1, 'p2':p2})
109
110        self.curs.execute("""DECLARE zot BINARY CURSOR FOR SELECT p1,p2 FROM %s
111                                           FOR READ ONLY""" % (self.tbl_name_3d,))
112        self.curs.execute("""FETCH ALL FROM zot""")
113        raw = self.curs.fetchall()
114        conn.commit()
115               
116        return raw
117
118    def _sub_test2dWKT(self,p1,p2):
119        self.curs.execute("INSERT INTO %s (p1,p2) VALUES (%%(p1)s, %%(p2)s)"  % (self.tbl_name_2d,),
120                          {'p1':p1, 'p2':p2})
121
122        self.curs.execute("SELECT p1,p2 FROM %s" % (self.tbl_name_2d,))
123
124        return  self.curs.fetchall()
125
126    def _sub_test3dWKT(self,p1,p2):
127
128        self.curs.execute("INSERT INTO %s (p1,p2) VALUES (%%(p1)s, %%(p2)s)"  % (self.tbl_name_3d,),
129                          {'p1':p1, 'p2':p2})
130
131        self.curs.execute("SELECT p1,p2 FROM %s" % (self.tbl_name_3d,))
132
133        return self.curs.fetchall()
134
135
136###########################  Point #############################################
137       
138class OGGeoTypesPointTestBase(OGGeoTypesTestBase):   
139
140    def setUp(self):
141        self._setUp('POINT')
142       
143    def tearDown(self):
144        self._tearDown
145       
146    def run2d(self,test_func):
147
148        p1 = GeoTypes.OGpointFromValues(1.0,2.0)
149        p2 = GeoTypes.OGpointFromValues(3.0,4.0)
150
151        raw = test_func(self,p1,p2)
152
153        ret = raw[0]
154
155        p3 = ret[0]
156        p4 = ret[1]
157       
158        assert p3.__class__.__name__ == "OGPoint"
159        assert p4.__class__.__name__ == "OGPoint"
160        assert p3.getX() == 1.0
161        assert p3.getY() == 2.0
162        assert p4.getX() == 3.0
163        assert p4.getY() == 4.0
164
165    def run3d(self,test_func):
166
167        p1 = GeoTypes.OGpointFromValues(1.0,2.0,3.0)
168        p2 = GeoTypes.OGpointFromValues(4.0,5.0,6.0)
169
170        raw = test_func(self,p1,p2)
171
172        ret = raw[0]
173
174        p3 = ret[0]
175        p4 = ret[1]
176
177        assert p3.__class__.__name__ == "OGPoint"
178        assert p4.__class__.__name__ == "OGPoint"
179        assert p3.getX() == 1.0
180        assert p3.getY() == 2.0
181        assert p3.getZ() == 3.0
182        assert p4.getX() == 4.0
183        assert p4.getY() == 5.0
184        assert p4.getZ() == 6.0
185 
186    def test3dWKB(self):
187        self.run3d(OGGeoTypesTestBase._sub_test3dWKB)
188
189    def test3dWKT(self):
190        self.run3d(OGGeoTypesTestBase._sub_test3dWKT)
191
192    def test2dWKB(self):
193        self.run2d(OGGeoTypesTestBase._sub_test2dWKB)
194
195    def test2dWKT(self):
196        self.run2d(OGGeoTypesTestBase._sub_test2dWKT)
197   
198     
199
200################################# LineString ######################################################
201   
202class OGGeoTypesLineStringTestBase(OGGeoTypesTestBase):   
203
204    def setUp(self):
205        self._setUp('LINESTRING')
206       
207    def tearDown(self):
208        self._tearDown
209       
210    def run2d(self,test_func):
211
212        p1 = GeoTypes.OGlineStringFromSequence(((1.0,2.0),(3.0,4.0)))
213        p2 = GeoTypes.OGlineStringFromSequence(((5.0,6.0),(7.0,8.0)))
214
215        raw = test_func(self,p1,p2)
216        ret = raw[0]
217
218        p3 = ret[0]
219        p4 = ret[1]
220
221        assert p3.__class__.__name__ == "OGLineString"
222        assert p4.__class__.__name__ == "OGLineString"
223        assert p3[0].getX() == 1.0
224        assert p3[0].getY() == 2.0
225        assert p3[1].getX() == 3.0
226        assert p3[1].getY() == 4.0
227        assert p4[0].getX() == 5.0
228        assert p4[0].getY() == 6.0
229
230    def run3d(self,test_func):
231
232        p1 = GeoTypes.OGlineStringFromSequence(((1.0,2.0,9.0),(3.0,4.0,10.0)))
233        p2 = GeoTypes.OGlineStringFromSequence(((5.0,6.0,11.0),(7.0,8.0,12.0)))
234
235        raw = test_func(self,p1,p2)
236
237        ret = raw[0]
238
239        p3 = ret[0]
240        p4 = ret[1]
241
242        assert p3.__class__.__name__ == "OGLineString"
243        assert p4.__class__.__name__ == "OGLineString"
244        assert p3[0].getX() == 1.0
245        assert p3[0].getY() == 2.0
246        assert p3[0].getZ() == 9.0
247        assert p4[0].getX() == 5.0
248        assert p4[0].getY() == 6.0
249        assert p4[0].getZ() == 11.0
250
251    def test3dWKB(self):
252        self.run3d(OGGeoTypesTestBase._sub_test3dWKB)
253
254    def test3dWKT(self):
255        self.run3d(OGGeoTypesTestBase._sub_test3dWKT)
256
257    def test2dWKB(self):
258        self.run2d(OGGeoTypesTestBase._sub_test2dWKB)
259
260    def test2dWKT(self):
261        self.run2d(OGGeoTypesTestBase._sub_test2dWKT)
262   
263
264       
265
266############################### Polygon ######################################################
267   
268class OGGeoTypesPolygonTestBase(OGGeoTypesTestBase):   
269
270    def setUp(self):
271        self._setUp('POLYGON')
272       
273    def tearDown(self):
274        self._tearDown
275       
276    def run2d(self,test_func):
277
278        p1 = GeoTypes.OGpolygonFromOGLines(
279            GeoTypes.OGlinearRingFromOGPoints(
280                    GeoTypes.OGpointFromValues(1,2),
281                    GeoTypes.OGpointFromValues(2,2),
282                    GeoTypes.OGpointFromValues(2,1),
283                    GeoTypes.OGpointFromValues(1,2),
284                    ),
285            GeoTypes.OGlinearRingFromOGPoints(
286                    GeoTypes.OGpointFromValues(1,2),
287                    GeoTypes.OGpointFromValues(2,2),
288                    GeoTypes.OGpointFromValues(2,1),
289                    GeoTypes.OGpointFromValues(1,2),
290                    )
291            )
292
293        p2 = GeoTypes.OGpolygonFromOGLines(
294            GeoTypes.OGlinearRingFromOGPoints(
295                    GeoTypes.OGpointFromValues(3,4),
296                    GeoTypes.OGpointFromValues(4,4),
297                    GeoTypes.OGpointFromValues(4,3),
298                    GeoTypes.OGpointFromValues(3,4),
299                    ),
300            GeoTypes.OGlinearRingFromOGPoints(
301                    GeoTypes.OGpointFromValues(3,4),
302                    GeoTypes.OGpointFromValues(4,4),
303                    GeoTypes.OGpointFromValues(4,3),
304                    GeoTypes.OGpointFromValues(3,4),
305                    )
306            )
307       
308        raw = test_func(self,p1,p2)
309
310        ret = raw[0]
311
312        p3 = ret[0]
313        p4 = ret[1]
314
315        assert p3.__class__.__name__ == "OGPolygon"
316        assert p4.__class__.__name__ == "OGPolygon"
317
318    def run3d(self,test_func):
319
320        p1 = GeoTypes.OGpolygonFromOGLines(
321            GeoTypes.OGlinearRingFromOGPoints(
322                    GeoTypes.OGpointFromValues(1,2,3),
323                    GeoTypes.OGpointFromValues(2,2,3),
324                    GeoTypes.OGpointFromValues(2,1,3),
325                    GeoTypes.OGpointFromValues(1,2,3),
326                    ),
327            GeoTypes.OGlinearRingFromOGPoints(
328                    GeoTypes.OGpointFromValues(1,2,3),
329                    GeoTypes.OGpointFromValues(2,2,3),
330                    GeoTypes.OGpointFromValues(2,1,3),
331                    GeoTypes.OGpointFromValues(1,2,3),
332                    )
333            )
334
335        p2 = GeoTypes.OGpolygonFromOGLines(
336            GeoTypes.OGlinearRingFromOGPoints(
337                    GeoTypes.OGpointFromValues(3,4,3),
338                    GeoTypes.OGpointFromValues(4,4,3),
339                    GeoTypes.OGpointFromValues(4,3,3),
340                    GeoTypes.OGpointFromValues(3,4,3),
341                    ),
342            GeoTypes.OGlinearRingFromOGPoints(
343                    GeoTypes.OGpointFromValues(3,4,3),
344                    GeoTypes.OGpointFromValues(4,4,3),
345                    GeoTypes.OGpointFromValues(4,3,3),
346                    GeoTypes.OGpointFromValues(3,4,3),
347                    )
348            )
349
350        raw = test_func(self,p1,p2)
351
352        ret = raw[0]
353
354        p3 = ret[0]
355        p4 = ret[1]
356
357        assert p3.__class__.__name__ == "OGPolygon"
358        assert p4.__class__.__name__ == "OGPolygon"
359
360    def test3dWKB(self):
361        self.run3d(OGGeoTypesTestBase._sub_test3dWKB)
362
363    def test3dWKT(self):
364        self.run3d(OGGeoTypesTestBase._sub_test3dWKT)
365
366    def test2dWKB(self):
367        self.run2d(OGGeoTypesTestBase._sub_test2dWKB)
368
369    def test2dWKT(self):
370        self.run2d(OGGeoTypesTestBase._sub_test2dWKT)
371   
372
373
374
375
376########################## MultiPoint ##################################################
377   
378
379class OGGeoTypesMultiPointTestBase(OGGeoTypesTestBase):   
380
381    def setUp(self):
382        self._setUp('MULTIPOINT')
383       
384    def tearDown(self):
385        self._tearDown
386       
387    def run2d(self,test_func):
388
389        p1 = GeoTypes.OGmultiPointFromSequence(((1.0,2.0),(3.0,4.0)))
390        p2 = GeoTypes.OGmultiPointFromSequence(((5.0,6.0),(7.0,8.0)))
391
392        raw = test_func(self,p1,p2)
393        ret = raw[0]
394
395        p3 = ret[0]
396        p4 = ret[1]
397
398        assert p3.__class__.__name__ == "OGMultiPoint"
399        assert p4.__class__.__name__ == "OGMultiPoint"
400   
401        assert p3[0].getX() == 1.0, "failed p3[0].getX() != %s" % str(p3[0].getX())
402        assert p3[0].getY() == 2.0
403        assert p3[1].getX() == 3.0
404        assert p3[1].getY() == 4.0
405        assert p4[0].getX() == 5.0
406        assert p4[0].getY() == 6.0
407
408    def run3d(self,test_func):
409
410        p1 = GeoTypes.OGmultiPointFromSequence(((1.0,2.0,9.0),(3.0,4.0,10.0)))
411        p2 = GeoTypes.OGmultiPointFromSequence(((5.0,6.0,11.0),(7.0,8.0,12.0)))
412
413        raw = test_func(self,p1,p2)
414
415        ret = raw[0]
416
417        p3 = ret[0]
418        p4 = ret[1]
419
420        assert p3.__class__.__name__ == "OGMultiPoint"
421        assert p4.__class__.__name__ == "OGMultiPoint"
422        assert p3[0].getX() == 1.0
423        assert p3[0].getY() == 2.0
424        assert p3[0].getZ() == 9.0
425        assert p4[0].getX() == 5.0
426        assert p4[0].getY() == 6.0
427        assert p4[0].getZ() == 11.0
428
429    def test3dWKB(self):
430        self.run3d(OGGeoTypesTestBase._sub_test3dWKB)
431
432    def test3dWKT(self):
433        self.run3d(OGGeoTypesTestBase._sub_test3dWKT)
434
435    def test2dWKB(self):
436        self.run2d(OGGeoTypesTestBase._sub_test2dWKB)
437
438    def test2dWKT(self):
439        self.run2d(OGGeoTypesTestBase._sub_test2dWKT)
440   
441
442   
443
444################### MultiLineString ###########################################
445
446class OGGeoTypesMultiLineStringTestBase(OGGeoTypesTestBase):   
447
448    def setUp(self):
449        self._setUp('MULTILINESTRING')
450       
451    def tearDown(self):
452        self._tearDown
453       
454    def run2d(self,test_func):
455       
456        p1 = GeoTypes.OGmultiLineStringFromOGLineStrings(
457            GeoTypes.OGlineStringFromSequence(((1.0,2.0),(3.0,4.0))),
458            GeoTypes.OGlineStringFromSequence(((5.0,6.0),(7.0,8.0))))
459        p2 = GeoTypes.OGmultiLineStringFromOGLineStrings(
460            GeoTypes.OGlineStringFromSequence(((1.0,2.0),(3.0,4.0))),
461            GeoTypes.OGlineStringFromSequence(((5.0,6.0),(7.0,8.0))))
462
463        raw = test_func(self,p1,p2)
464        ret = raw[0]
465
466        p3 = ret[0]
467        p4 = ret[1]
468
469        assert p3.__class__.__name__ == "OGMultiLineString"
470        assert p4.__class__.__name__ == "OGMultiLineString"
471
472    def run3d(self,test_func):
473       
474        p1 = GeoTypes.OGmultiLineStringFromOGLineStrings(
475            GeoTypes.OGlineStringFromSequence(((1.0,2.0,9.0),(3.0,4.0,10.0))),
476            GeoTypes.OGlineStringFromSequence(((5.0,6.0,11.0),(7.0,8.0,12.0))))
477        p2 = GeoTypes.OGmultiLineStringFromOGLineStrings(
478            GeoTypes.OGlineStringFromSequence(((1.0,2.0,9.0),(3.0,4.0,10.0))),
479            GeoTypes.OGlineStringFromSequence(((5.0,6.0,11.0),(7.0,8.0,12.0))))
480
481        raw = test_func(self,p1,p2)
482
483        ret = raw[0]
484
485        p3 = ret[0]
486        p4 = ret[1]
487
488        assert p3.__class__.__name__ == "OGMultiLineString"
489        assert p4.__class__.__name__ == "OGMultiLineString"
490
491    def test3dWKB(self):
492        self.run3d(OGGeoTypesTestBase._sub_test3dWKB)
493
494    def test3dWKT(self):
495        self.run3d(OGGeoTypesTestBase._sub_test3dWKT)
496
497    def test2dWKB(self):
498        self.run2d(OGGeoTypesTestBase._sub_test2dWKB)
499
500    def test2dWKT(self):
501        self.run2d(OGGeoTypesTestBase._sub_test2dWKT)
502   
503################### MultiPolygon ###############################################
504
505class OGGeoTypesMultiPolygonTestBase(OGGeoTypesTestBase):   
506
507    def setUp(self):
508        self._setUp('MULTIPOLYGON')
509       
510    def tearDown(self):
511        self._tearDown
512       
513    def run2d(self,test_func):
514       
515        p1 = GeoTypes.OGmultiPolygonFromOGPolygons(
516              GeoTypes.OGpolygonFromOGLines(
517                 GeoTypes.OGlinearRingFromOGPoints(
518                    GeoTypes.OGpointFromValues(3,4),
519                    GeoTypes.OGpointFromValues(4,4),
520                    GeoTypes.OGpointFromValues(4,3),
521                    GeoTypes.OGpointFromValues(3,4),
522                    ),
523                 GeoTypes.OGlinearRingFromOGPoints(
524                    GeoTypes.OGpointFromValues(3,4),
525                    GeoTypes.OGpointFromValues(4,4),
526                    GeoTypes.OGpointFromValues(4,3),
527                    GeoTypes.OGpointFromValues(3,4),
528                    )
529                 ),
530               GeoTypes.OGpolygonFromOGLines(
531                 GeoTypes.OGlinearRingFromOGPoints(
532                    GeoTypes.OGpointFromValues(3,4),
533                    GeoTypes.OGpointFromValues(4,4),
534                    GeoTypes.OGpointFromValues(4,3),
535                    GeoTypes.OGpointFromValues(3,4),
536                    ),
537                 GeoTypes.OGlinearRingFromOGPoints(
538                    GeoTypes.OGpointFromValues(3,4),
539                    GeoTypes.OGpointFromValues(4,4),
540                    GeoTypes.OGpointFromValues(4,3),
541                    GeoTypes.OGpointFromValues(3,4),
542                    )
543                 )
544               )
545
546        p2 = p1
547
548        raw = test_func(self,p1,p2)
549        ret = raw[0]
550
551        p3 = ret[0]
552        p4 = ret[1]
553
554        assert p3.__class__.__name__ == "OGMultiPolygon"
555        assert p4.__class__.__name__ == "OGMultiPolygon"
556
557    def run3d(self,test_func):
558
559        p1 = GeoTypes.OGmultiPolygonFromOGPolygons(
560               GeoTypes.OGpolygonFromOGLines(
561                 GeoTypes.OGlinearRingFromOGPoints(
562                    GeoTypes.OGpointFromValues(1,2,3),
563                    GeoTypes.OGpointFromValues(2,2,3),
564                    GeoTypes.OGpointFromValues(2,1,3),
565                    GeoTypes.OGpointFromValues(1,2,3),
566                    ),
567                 GeoTypes.OGlinearRingFromOGPoints(
568                    GeoTypes.OGpointFromValues(1,2,3),
569                    GeoTypes.OGpointFromValues(2,2,3),
570                    GeoTypes.OGpointFromValues(2,1,3),
571                    GeoTypes.OGpointFromValues(1,2,3),
572                    )
573                 ),
574              GeoTypes.OGpolygonFromOGLines(
575                 GeoTypes.OGlinearRingFromOGPoints(
576                    GeoTypes.OGpointFromValues(3,4,3),
577                    GeoTypes.OGpointFromValues(4,4,3),
578                    GeoTypes.OGpointFromValues(4,3,3),
579                    GeoTypes.OGpointFromValues(3,4,3),
580                    ),
581                 GeoTypes.OGlinearRingFromOGPoints(
582                    GeoTypes.OGpointFromValues(3,4,3),
583                    GeoTypes.OGpointFromValues(4,4,3),
584                    GeoTypes.OGpointFromValues(4,3,3),
585                    GeoTypes.OGpointFromValues(3,4,3),
586                    )
587                 )
588               )
589               
590        p2 = p1
591
592        raw = test_func(self,p1,p2)
593
594        ret = raw[0]
595
596        p3 = ret[0]
597        p4 = ret[1]
598
599        assert p3.__class__.__name__ == "OGMultiPolygon"
600        assert p4.__class__.__name__ == "OGMultiPolygon"
601
602    def test3dWKB(self):
603        self.run3d(OGGeoTypesTestBase._sub_test3dWKB)
604
605    def test3dWKT(self):
606        self.run3d(OGGeoTypesTestBase._sub_test3dWKT)
607
608    def test2dWKB(self):
609        self.run2d(OGGeoTypesTestBase._sub_test2dWKB)
610
611    def test2dWKT(self):
612        self.run2d(OGGeoTypesTestBase._sub_test2dWKT)
613
614
615##################### GeometryCollection ##########################################
616
617class OGGeoTypesGeometryCollectionTestBase(OGGeoTypesTestBase):   
618
619    def setUp(self):
620        self._setUp('GEOMETRYCOLLECTION')
621       
622    def tearDown(self):
623        self._tearDown
624       
625    def run2d(self,test_func):
626       
627        p1 = GeoTypes.OGgeometryCollectionFromOGGeometries(
628
629              #  A Polyon
630           
631              GeoTypes.OGpolygonFromOGLines(
632                 GeoTypes.OGlinearRingFromOGPoints(
633                    GeoTypes.OGpointFromValues(3,4),
634                    GeoTypes.OGpointFromValues(4,4),
635                    GeoTypes.OGpointFromValues(4,3),
636                    GeoTypes.OGpointFromValues(3,4),
637                    ),
638                 GeoTypes.OGlinearRingFromOGPoints(
639                    GeoTypes.OGpointFromValues(3,4),
640                    GeoTypes.OGpointFromValues(4,4),
641                    GeoTypes.OGpointFromValues(4,3),
642                    GeoTypes.OGpointFromValues(3,4),
643                    )
644                 ),
645
646                # A Linearing
647             
648              GeoTypes.OGlinearRingFromOGPoints(
649                 GeoTypes.OGpointFromValues(3,4),
650                 GeoTypes.OGpointFromValues(4,4),
651                 GeoTypes.OGpointFromValues(4,3),
652                 GeoTypes.OGpointFromValues(3,4),
653                 ),
654
655               )
656
657        p2 = p1
658
659        raw = test_func(self,p1,p2)
660        ret = raw[0]
661
662        p3 = ret[0]
663        p4 = ret[1]
664
665        assert p3.__class__.__name__ == "OGGeometryCollection"
666        assert p4.__class__.__name__ == "OGGeometryCollection"
667
668    def run3d(self,test_func):
669
670        p1 = GeoTypes.OGgeometryCollectionFromOGGeometries(
671           
672               # A Polygon
673           
674               GeoTypes.OGpolygonFromOGLines(
675                 GeoTypes.OGlinearRingFromOGPoints(
676                    GeoTypes.OGpointFromValues(1,2,3),
677                    GeoTypes.OGpointFromValues(2,2,3),
678                    GeoTypes.OGpointFromValues(2,1,3),
679                    GeoTypes.OGpointFromValues(1,2,3),
680                    ),
681                 GeoTypes.OGlinearRingFromOGPoints(
682                    GeoTypes.OGpointFromValues(1,2,3),
683                    GeoTypes.OGpointFromValues(2,2,3),
684                    GeoTypes.OGpointFromValues(2,1,3),
685                    GeoTypes.OGpointFromValues(1,2,3),
686                    )
687                 ),
688
689               # A Linear Ring
690               GeoTypes.OGlinearRingFromOGPoints(
691                 GeoTypes.OGpointFromValues(3,4,3),
692                 GeoTypes.OGpointFromValues(4,4,3),
693                 GeoTypes.OGpointFromValues(4,3,3),
694                 GeoTypes.OGpointFromValues(3,4,3),
695                 ),
696               )
697               
698        p2 = p1
699
700        raw = test_func(self,p1,p2)
701
702        ret = raw[0]
703
704        p3 = ret[0]
705        p4 = ret[1]
706
707        assert p3.__class__.__name__ == "OGGeometryCollection"
708        assert p4.__class__.__name__ == "OGGeometryCollection"
709
710    def test3dWKB(self):
711        self.run3d(OGGeoTypesTestBase._sub_test3dWKB)
712
713    def test3dWKT(self):
714        self.run3d(OGGeoTypesTestBase._sub_test3dWKT)
715
716    def test2dWKB(self):
717        self.run2d(OGGeoTypesTestBase._sub_test2dWKB)
718
719    def test2dWKT(self):
720        self.run2d(OGGeoTypesTestBase._sub_test2dWKT)
721
722
723def testSuite():
724    return unittest.TestSuite((
725        unittest.makeSuite(OGGeoTypesPointTestBase,'test'),
726        unittest.makeSuite(OGGeoTypesLineStringTestBase,'test'),
727        unittest.makeSuite(OGGeoTypesPolygonTestBase,'test'),
728        unittest.makeSuite(OGGeoTypesMultiPointTestBase,'test'),
729        unittest.makeSuite(OGGeoTypesMultiLineStringTestBase,'test'),
730        unittest.makeSuite(OGGeoTypesMultiPolygonTestBase,'test'),
731        unittest.makeSuite(OGGeoTypesGeometryCollectionTestBase,'test'),
732        ))
733
734if __name__ == "__main__":
735    import os
736    if os.environ.get('USECOVERAGE') == '1':
737        try:
738            import coverage
739            coverage.erase()
740            coverage.start()
741            COVERAGE = 1
742            import GeoTypes         
743
744        except:
745            print "Error setting up coverage checking"
746            COVERAGE = 0
747    else:
748        COVERAGE = 0
749
750    if os.environ.get('USEPYCHECK') == '1':
751        try:
752            import pychecker.checker
753        except:
754            print "Pychecker not installed on this machine"
755
756
757    unittest.TextTestRunner().run(testSuite())
758
759    if COVERAGE:
760        coverage.stop()
761        x = coverage.analysis(GeoTypes)
762        print "\n"
763        coverage.report(GeoTypes)
764
765
Note: See TracBrowser for help on using the repository browser.