shapely 1.2.13__py2.6-win-amd64.egg → 1.2.18__py2.6-win-amd64.egg

shapely/tests/test_affinity.py

@@ -0,0 +1,239 @@
+import unittest
+from math import pi
+from shapely import affinity
+from shapely.wkt import loads as load_wkt
+from shapely.geometry import Point
+
+class AffineTestCase(unittest.TestCase):
+
+    def test_affine_params(self):
+        g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
+        self.assertRaises(
+            TypeError, affinity.affine_transform, g, None)
+        self.assertRaises(
+            TypeError, affinity.affine_transform, g, '123456')
+        self.assertRaises(ValueError, 
+            affinity.affine_transform, g, [1,2,3,4,5,6,7,8,9])
+        self.assertRaises(AttributeError, 
+            affinity.affine_transform, None, [1,2,3,4,5,6])
+
+    def test_affine_geom_types(self):
+        matrix2d = (1, 0,
+                    0, 1,
+                    0, 0)
+        matrix3d = (1, 0, 0,
+                    0, 1, 0,
+                    0, 0, 1,
+                    0, 0, 0)
+        def test_geom(g2, g3=None):
+            self.assertFalse(g2.has_z)
+            a2 = affinity.affine_transform(g2, matrix2d)
+            self.assertFalse(a2.has_z)
+            self.assertTrue(g2.equals(a2))
+            if g3 is not None:
+                self.assertTrue(g3.has_z)
+                a3 = affinity.affine_transform(g3, matrix3d)
+                self.assertTrue(a3.has_z)
+                self.assertTrue(g3.equals(a3))
+            return
+        pt2d = load_wkt('POINT(12.3 45.6)')
+        pt3d = load_wkt('POINT(12.3 45.6 7.89)')
+        test_geom(pt2d, pt3d)
+        ls2d = load_wkt('LINESTRING(0.9 3.4, 0.7 2, 2.5 2.7)')
+        ls3d = load_wkt('LINESTRING(0.9 3.4 3.3, 0.7 2 2.3, 2.5 2.7 5.5)')
+        test_geom(ls2d, ls3d)
+        test_geom(load_wkt('POLYGON((0.9 2.3, 0.5 1.1, 2.4 0.8, 0.9 2.3), '\
+                           '(1.1 1.7, 0.9 1.3, 1.4 1.2, 1.1 1.7), '\
+                           '(1.6 1.3, 1.7 1, 1.9 1.1, 1.6 1.3))'))
+        test_geom(load_wkt('MULTIPOINT ((-300 300), (700 300), '\
+                           '(-800 -1100), (200 -300))'))
+        test_geom(load_wkt('MULTILINESTRING((0 0, -0.7 -0.7, 0.6 -1), '\
+                           '(-0.5 0.5, 0.7 0.6, 0 -0.6))'))
+        test_geom(load_wkt('MULTIPOLYGON(((900 4300, -1100 -400, '\
+                           '900 -800, 900 4300)), '\
+                           '((1200 4300, 2300 4400, 1900 1000, 1200 4300)))'))
+        # GeometryCollection fails, since it does not have a good constructor
+        gc = load_wkt('GEOMETRYCOLLECTION(POINT(20 70),'\
+                      ' POLYGON((60 70, 13 35, 60 -30, 60 70)),'\
+                      ' LINESTRING(60 70, 50 100, 80 100))')
+        self.assertRaises(TypeError, test_geom, gc) # TODO: fix this
+
+    def test_affine_2d(self):
+        g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
+        # custom scale and translate
+        expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
+        matrix2d = (2, 0,
+                    0, 2.5,
+                    -5, 4.1)
+        a2 = affinity.affine_transform(g, matrix2d)
+        self.assertTrue(a2.almost_equals(expected2d))
+        self.assertFalse(a2.has_z)
+        # Make sure a 3D matrix does not make a 3D shape from a 2D input
+        matrix3d = (2, 0, 0,
+                    0, 2.5, 0,
+                    0, 0, 10,
+                    -5, 4.1, 100)
+        a3 = affinity.affine_transform(g, matrix3d)
+        self.assertTrue(a3.almost_equals(expected2d))
+        self.assertFalse(a3.has_z)
+
+    def test_affine_3d(self):
+        g2 = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
+        g3 = load_wkt('LINESTRING(2.4 4.1 100.2, 2.4 3 132.8, 3 3 128.6)')
+        # custom scale and translate
+        matrix2d = (2, 0,
+                    0, 2.5,
+                    -5, 4.1)
+        matrix3d = (2, 0, 0,
+                    0, 2.5, 0,
+                    0, 0, 0.3048,
+                    -5, 4.1, 100)
+        # Combinations of 2D and 3D geometries and matrices
+        a22 = affinity.affine_transform(g2, matrix2d)
+        a23 = affinity.affine_transform(g2, matrix3d)
+        a32 = affinity.affine_transform(g3, matrix2d)
+        a33 = affinity.affine_transform(g3, matrix3d)
+        # Check dimensions
+        self.assertFalse(a22.has_z)
+        self.assertFalse(a23.has_z)
+        self.assertTrue(a32.has_z)
+        self.assertTrue(a33.has_z)
+        # 2D equality checks
+        expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
+        expected3d = load_wkt('LINESTRING(-0.2 14.35 130.54096, '\
+                              '-0.2 11.6 140.47744, 1 11.6 139.19728)')
+        expected32 = load_wkt('LINESTRING(-0.2 14.35 100.2, '\
+                              '-0.2 11.6 132.8, 1 11.6 128.6)')
+        self.assertTrue(a22.almost_equals(expected2d))
+        self.assertTrue(a23.almost_equals(expected2d))
+        # Do explicit 3D check of coordinate values
+        for a, e in zip(a32.coords, expected32.coords):
+            for ap, ep in zip(a, e):
+                self.assertAlmostEqual(ap, ep)
+        for a, e in zip(a33.coords, expected3d.coords):
+            for ap, ep in zip(a, e):
+                self.assertAlmostEqual(ap, ep)
+
+class TransformOpsTestCase(unittest.TestCase):
+
+    def test_rotate(self):
+        ls = load_wkt('LINESTRING(240 400, 240 300, 300 300)')
+        # counter-clockwise degrees
+        rls = affinity.rotate(ls, 90)
+        els = load_wkt('LINESTRING(220 320, 320 320, 320 380)')
+        self.assertTrue(rls.equals(els))
+        # retest with named parameters for the same result
+        rls = affinity.rotate(geom=ls, angle=90, origin='center')
+        self.assertTrue(rls.equals(els))
+        # clockwise radians
+        rls = affinity.rotate(ls, -pi/2, use_radians=True)
+        els = load_wkt('LINESTRING(320 380, 220 380, 220 320)')
+        self.assertTrue(rls.equals(els))
+        ## other `origin` parameters
+        # around the centroid
+        rls = affinity.rotate(ls, 90, origin='centroid')
+        els = load_wkt('LINESTRING(182.5 320, 282.5 320, 282.5 380)')
+        self.assertTrue(rls.equals(els))
+        # around the second coordinate tuple
+        rls = affinity.rotate(ls, 90, origin=ls.coords[1])
+        els = load_wkt('LINESTRING(140 300, 240 300, 240 360)')
+        self.assertTrue(rls.equals(els))
+        # around the absolute Point of origin
+        rls = affinity.rotate(ls, 90, origin=Point(0,0))
+        els = load_wkt('LINESTRING(-400 240, -300 240, -300 300)')
+        self.assertTrue(rls.equals(els))
+
+    def test_scale(self):
+        ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
+        # test defaults of 1.0
+        sls = affinity.scale(ls)
+        self.assertTrue(sls.equals(ls))
+        # different scaling in different dimensions
+        sls = affinity.scale(ls, 2, 3, 0.5)
+        els = load_wkt('LINESTRING(210 500 5, 210 200 15, 330 200 10)')
+        self.assertTrue(sls.equals(els))
+        # Do explicit 3D check of coordinate values
+        for a, b in zip(sls.coords, els.coords):
+            for ap, bp in zip(a, b):
+                self.assertEqual(ap, bp)
+        # retest with named parameters for the same result
+        sls = affinity.scale(geom=ls, xfact=2, yfact=3, zfact=0.5,
+                              origin='center')
+        self.assertTrue(sls.equals(els))
+        ## other `origin` parameters
+        # around the centroid
+        sls = affinity.scale(ls, 2, 3, 0.5, origin='centroid')
+        els = load_wkt('LINESTRING(228.75 537.5, 228.75 237.5, 348.75 237.5)')
+        self.assertTrue(sls.equals(els))
+        # around the second coordinate tuple
+        sls = affinity.scale(ls, 2, 3, 0.5, origin=ls.coords[1])
+        els = load_wkt('LINESTRING(240 600, 240 300, 360 300)')
+        self.assertTrue(sls.equals(els))
+        # around some other 3D Point of origin
+        sls = affinity.scale(ls, 2, 3, 0.5, origin=Point(100, 200, 1000))
+        els = load_wkt('LINESTRING(380 800 505, 380 500 515, 500 500 510)')
+        self.assertTrue(sls.equals(els))
+        # Do explicit 3D check of coordinate values
+        for a, b in zip(sls.coords, els.coords):
+            for ap, bp in zip(a, b):
+                self.assertEqual(ap, bp)
+
+    def test_skew(self):
+        ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
+        # test default shear angles of 0.0
+        sls = affinity.skew(ls)
+        self.assertTrue(sls.equals(ls))
+        # different shearing in x- and y-directions
+        sls = affinity.skew(ls, 15, -30)
+        els = load_wkt('LINESTRING (253.39745962155615 417.3205080756888, '\
+                       '226.60254037844385 317.3205080756888, '\
+                       '286.60254037844385 282.67949192431126)')
+        self.assertTrue(sls.almost_equals(els))
+        # retest with radians for the same result
+        sls = affinity.skew(ls, pi/12, -pi/6, use_radians=True)
+        self.assertTrue(sls.almost_equals(els))
+        # retest with named parameters for the same result
+        sls = affinity.skew(geom=ls, xs=15, ys=-30,
+                             origin='center', use_radians=False)
+        self.assertTrue(sls.almost_equals(els))
+        ## other `origin` parameters
+        # around the centroid
+        sls = affinity.skew(ls, 15, -30, origin='centroid')
+        els = load_wkt('LINESTRING(258.42150697963973 406.49519052838332, '\
+                       '231.6265877365273980 306.4951905283833185, '\
+                       '291.6265877365274264 271.8541743770057337)')
+        self.assertTrue(sls.almost_equals(els))
+        # around the second coordinate tuple
+        sls = affinity.skew(ls, 15, -30, origin=ls.coords[1])
+        els = load_wkt('LINESTRING(266.7949192431123038 400, 240 300, '\
+                       '300 265.3589838486224153)')
+        self.assertTrue(sls.almost_equals(els))
+        # around the absolute Point of origin
+        sls = affinity.skew(ls, 15, -30, origin=Point(0,0))
+        els = load_wkt('LINESTRING(347.179676972449101 261.435935394489832, '\
+                       '320.3847577293367976 161.4359353944898317, '\
+                       '380.3847577293367976 126.7949192431122754)')
+        self.assertTrue(sls.almost_equals(els))
+
+    def test_translate(self):
+        ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
+        # test default offset of 0.0
+        tls = affinity.translate(ls)
+        self.assertTrue(tls.equals(ls))
+        # test all offsets
+        tls = affinity.translate(ls, 100, 400, -10)
+        els = load_wkt('LINESTRING(340 800 0, 340 700 20, 400 700 10)')
+        self.assertTrue(tls.equals(els))
+        # Do explicit 3D check of coordinate values
+        for a, b in zip(tls.coords, els.coords):
+            for ap, bp in zip(a, b):
+                self.assertEqual(ap, bp)
+        # retest with named parameters for the same result
+        tls = affinity.translate(geom=ls, xoff=100, yoff=400, zoff=-10)
+        self.assertTrue(tls.equals(els))
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        unittest.TestLoader().loadTestsFromTestCase(AffineTestCase),
+        unittest.TestLoader().loadTestsFromTestCase(TransformOpsTestCase)])

shapely/tests/test_collection.py

@@ -1,4 +1,5 @@
 import unittest
+from shapely.geometry import LineString
 from shapely.geometry.collection import GeometryCollection
 
 class CollectionTestCase(unittest.TestCase):
@@ -7,5 +8,19 @@ class CollectionTestCase(unittest.TestCase):
         self.failUnlessEqual(len(m), 0)
         self.failUnlessEqual(m.geoms, [])
 
+    def test_child_with_deleted_parent(self):
+        # test that we can remove a collection while having
+        # childs around
+        a = LineString([(0, 0), (1, 1), (1,2), (2,2)])
+        b = LineString([(0, 0), (1, 1), (2,1), (2,2)])
+        collection = a.intersection(b)
+
+        child = collection.geoms[0]
+        # delete parent of child
+        del collection
+
+        # access geometry, this should not seg fault as 1.2.15 did
+        child.to_wkt()
+
 def test_suite():
     return unittest.TestLoader().loadTestsFromTestCase(CollectionTestCase)

shapely/tests/test_dlls.py

@@ -6,7 +6,7 @@ class LoadingTestCase(unittest.TestCase):
     def test_load(self):
         self.assertRaises(OSError, load_dll, 'geosh_c')
     def test_fallbacks(self):
-        a = load_dll('geosh_c', fallbacks=[
+        a = load_dll('geos_c', fallbacks=[
             '/opt/local/lib/libgeos_c.dylib', # MacPorts
             '/usr/local/lib/libgeos_c.dylib', # homebrew (Mac OS X)
             'libgeos_c.so.1',

shapely/tests/test_emptiness.py

@@ -1,19 +1,52 @@
 import unittest
 from shapely.geometry.base import BaseGeometry
-from shapely.geometry import Point
+import shapely.geometry as sgeom
+from shapely.geometry.polygon import LinearRing
+
 
 class EmptinessTestCase(unittest.TestCase):
     def test_empty_base(self):
         g = BaseGeometry()
-        self.failUnless(g._is_empty, True)
-    def test_empty_point(self):
-        p = Point()
-        self.failUnless(p._is_empty, True)
+        self.assertTrue(g._is_empty)
+
     def test_emptying_point(self):
-        p = Point(0, 0)
-        self.failIf(p._is_empty, False)
+        p = sgeom.Point(0, 0)
+        self.assertFalse(p._is_empty)
         p.empty()
-        self.failUnless(p._is_empty, True)
+        self.assertTrue(p._is_empty)
+
+    def test_none_geom(self):
+        p = BaseGeometry()
+        p._geom = None
+        self.assertTrue(p.is_empty)
+
+    def test_empty_point(self):
+        self.assertTrue(sgeom.Point().is_empty)
+        
+    def test_empty_multipoint(self):
+        self.assertTrue(sgeom.MultiPoint().is_empty)
+
+    def test_empty_geometry_collection(self):
+        self.assertTrue(sgeom.GeometryCollection().is_empty)
+
+    def test_empty_linestring(self):
+        self.assertTrue(sgeom.LineString().is_empty)
+
+    def test_empty_multilinestring(self):
+        self.assertTrue(sgeom.MultiLineString([]).is_empty)
+
+    def test_empty_polygon(self):
+        self.assertTrue(sgeom.Polygon().is_empty)
+
+    def test_empty_multipolygon(self):
+        self.assertTrue(sgeom.MultiPolygon([]).is_empty)
+
+    def test_empty_linear_ring(self):
+        self.assertTrue(LinearRing().is_empty)
+
 
 def test_suite():
     return unittest.TestLoader().loadTestsFromTestCase(EmptinessTestCase)
+
+if __name__ == '__main__':
+    unittest.main()

shapely/tests/test_getitem.py

@@ -0,0 +1,113 @@
+import unittest
+from shapely import geometry
+
+class CoordsGetItemTestCase(unittest.TestCase):
+    def test_index_2d_coords(self):
+        c = [(float(x), float(-x)) for x in range(4)]
+        g = geometry.LineString(c)
+        for i in range(-4,4):
+            self.assertTrue(g.coords[i] == c[i])
+        self.assertRaises(IndexError, lambda: g.coords[4])
+        self.assertRaises(IndexError, lambda: g.coords[-5])
+
+    def test_index_3d_coords(self):
+        c = [(float(x), float(-x), float(x*2)) for x in range(4)]
+        g = geometry.LineString(c)
+        for i in range(-4,4):
+            self.assertTrue(g.coords[i] == c[i])
+        self.assertRaises(IndexError, lambda: g.coords[4])
+        self.assertRaises(IndexError, lambda: g.coords[-5])
+
+    def test_index_coords_misc(self):
+        g = geometry.LineString() # empty
+        self.assertRaises(IndexError, lambda: g.coords[0])
+        self.assertRaises(TypeError, lambda: g.coords[0.0])
+
+    def test_slice_2d_coords(self):
+        c = [(float(x), float(-x)) for x in range(4)]
+        g = geometry.LineString(c)
+        self.assertTrue(g.coords[1:] == c[1:])
+        self.assertTrue(g.coords[:-1] == c[:-1])
+        self.assertTrue(g.coords[::-1] == c[::-1])
+        self.assertTrue(g.coords[::2] == c[::2])
+        self.assertTrue(g.coords[:4] == c[:4])
+        self.assertTrue(g.coords[4:] == c[4:] == [])
+
+    def test_slice_3d_coords(self):
+        c = [(float(x), float(-x), float(x*2)) for x in range(4)]
+        g = geometry.LineString(c)
+        self.assertTrue(g.coords[1:] == c[1:])
+        self.assertTrue(g.coords[:-1] == c[:-1])
+        self.assertTrue(g.coords[::-1] == c[::-1])
+        self.assertTrue(g.coords[::2] == c[::2])
+        self.assertTrue(g.coords[:4] == c[:4])
+        self.assertTrue(g.coords[4:] == c[4:] == [])
+
+class MultiGeomGetItemTestCase(unittest.TestCase):
+    def test_index_multigeom(self):
+        c = [(float(x), float(-x)) for x in range(4)]
+        g = geometry.MultiPoint(c)
+        for i in range(-4,4):
+            self.assertTrue(g[i].equals(geometry.Point(c[i])))
+        self.assertRaises(IndexError, lambda: g[4])
+        self.assertRaises(IndexError, lambda: g[-5])
+
+    def test_index_multigeom_misc(self):
+        g = geometry.MultiLineString() # empty
+        self.assertRaises(IndexError, lambda: g[0])
+        self.assertRaises(TypeError, lambda: g[0.0])
+
+    def test_slice_multigeom(self):
+        c = [(float(x), float(-x)) for x in range(4)]
+        g = geometry.MultiPoint(c)
+        self.failUnlessEqual(type(g[:]), type(g))
+        self.failUnlessEqual(len(g[:]), len(g))
+        self.failUnless(g[1:].equals(geometry.MultiPoint(c[1:])))
+        self.failUnless(g[:-1].equals(geometry.MultiPoint(c[:-1])))
+        self.failUnless(g[::-1].equals(geometry.MultiPoint(c[::-1])))
+        self.failUnless(g[4:].is_empty)
+
+class LinearRingGetItemTestCase(unittest.TestCase):
+    def test_index_linearring(self):
+        shell = geometry.polygon.LinearRing([(0.0, 0.0), (70.0, 120.0),
+                                             (140.0, 0.0), (0.0, 0.0)])
+        holes = [geometry.polygon.LinearRing([(60.0, 80.0), (80.0, 80.0),
+                                              (70.0, 60.0), (60.0, 80.0)]),
+                 geometry.polygon.LinearRing([(30.0, 10.0), (50.0, 10.0),
+                                              (40.0, 30.0), (30.0, 10.0)]),
+                 geometry.polygon.LinearRing([(90.0, 10), (110.0, 10.0),
+                                              (100.0, 30.0), (90.0, 10.0)])]
+        g = geometry.Polygon(shell, holes)
+        for i in range(-3,3):
+            self.assertTrue(g.interiors[i].equals(holes[i]))
+        self.assertRaises(IndexError, lambda: g.interiors[3])
+        self.assertRaises(IndexError, lambda: g.interiors[-4])
+
+    def test_index_linearring_misc(self):
+        g = geometry.Polygon() # empty
+        self.assertRaises(IndexError, lambda: g.interiors[0])
+        self.assertRaises(TypeError, lambda: g.interiors[0.0])
+
+    def test_slice_linearring(self):
+        shell = geometry.polygon.LinearRing([(0.0, 0.0), (70.0, 120.0),
+                                             (140.0, 0.0), (0.0, 0.0)])
+        holes = [geometry.polygon.LinearRing([(60.0, 80.0), (80.0, 80.0),
+                                              (70.0, 60.0), (60.0, 80.0)]),
+                 geometry.polygon.LinearRing([(30.0, 10.0), (50.0, 10.0),
+                                              (40.0, 30.0), (30.0, 10.0)]),
+                 geometry.polygon.LinearRing([(90.0, 10), (110.0, 10.0),
+                                              (100.0, 30.0), (90.0, 10.0)])]
+        g = geometry.Polygon(shell, holes)
+        self.assertTrue(all([a.equals(b) for (a, b) in zip(g.interiors[1:], holes[1:])]))
+        self.assertTrue(all([a.equals(b) for (a, b) in zip(g.interiors[:-1], holes[:-1])]))
+        self.assertTrue(all([a.equals(b) for (a, b) in zip(g.interiors[::-1], holes[::-1])]))
+        self.assertTrue(all([a.equals(b) for (a, b) in zip(g.interiors[::2], holes[::2])]))
+        self.assertTrue(all([a.equals(b) for (a, b) in zip(g.interiors[:3], holes[:3])]))
+        self.assertTrue(g.interiors[3:] == holes[3:] == [])
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        unittest.TestLoader().loadTestsFromTestCase(CoordsGetItemTestCase),
+        unittest.TestLoader().loadTestsFromTestCase(MultiGeomGetItemTestCase),
+        unittest.TestLoader().loadTestsFromTestCase(LinearRingGetItemTestCase)])

shapely/tests/test_ndarrays.py

@@ -0,0 +1,35 @@
+# Tests of support for Numpy ndarrays. See
+# https://github.com/sgillies/shapely/issues/26 for discussion.
+# Requires numpy.
+
+import unittest
+from shapely import geometry
+import numpy
+
+class TransposeTestCase(unittest.TestCase):
+    def test_multipoint(self):
+        a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.asMultiPoint(t)
+        coords = reduce(lambda x, y: x + y, [list(g.coords) for g in s])
+        self.failUnlessEqual(
+            coords,
+            [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
+    def test_linestring(self):
+        a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.asLineString(t)
+        self.failUnlessEqual(
+            list(s.coords),
+            [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
+    def test_polygon(self):
+        a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.asPolygon(t)
+        self.failUnlessEqual(
+            list(s.exterior.coords),
+            [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(TransposeTestCase)
+

shapely/tests/test_pickle.py

@@ -0,0 +1,15 @@
+from cPickle import dumps, loads, HIGHEST_PROTOCOL
+import unittest
+from shapely import geometry
+
+class TwoDeeTestCase(unittest.TestCase):
+    """."""
+    def test_linestring(self):
+        l = geometry.LineString(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)))
+        self.failUnlessEqual(l._ndim, 2)
+        s = dumps(l, HIGHEST_PROTOCOL)
+        t = loads(s)
+        self.failUnlessEqual(t._ndim, 2)
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(TwoDeeTestCase)

shapely/tests/test_styles.py

@@ -0,0 +1,17 @@
+import unittest
+from shapely.geometry import CAP_STYLE, JOIN_STYLE
+
+class StylesTest(unittest.TestCase):
+    def test_cap(self):
+        self.assertEqual(CAP_STYLE.round, 1)
+        self.assertEqual(CAP_STYLE.flat, 2)
+        self.assertEqual(CAP_STYLE.square, 3)
+    def test_join(self):
+        self.assertEqual(JOIN_STYLE.round, 1)
+        self.assertEqual(JOIN_STYLE.mitre, 2)
+        self.assertEqual(JOIN_STYLE.bevel, 3)
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        unittest.TestLoader().loadTestsFromTestCase(StylesTest)])

shapely/tests/test_transform.py

@@ -0,0 +1,61 @@
+import unittest
+from shapely import geometry
+from shapely.ops import transform
+
+class IdentityTestCase(unittest.TestCase):
+    """New geometry/coordseq method 'xy' makes numpy interop easier"""
+    def func(self, x, y, z=None):
+        return tuple(filter(None, [x, y, z]))
+    def test_point(self):
+        g = geometry.Point(0, 1)
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'Point')
+        self.failUnlessEqual(list(h.coords), [(0, 1)])
+    def test_line(self):
+        g = geometry.LineString(((0, 1), (2, 3)))
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'LineString')
+        self.failUnlessEqual(list(h.coords), [(0, 1), (2, 3)])
+    def test_polygon(self):
+        g = geometry.Point(0, 1).buffer(1.0)
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'Polygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+    def test_multipolygon(self):
+        g = geometry.MultiPoint([(0, 1), (0, 4)]).buffer(1.0)
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'MultiPolygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+
+class LambdaTestCase(unittest.TestCase):
+    """New geometry/coordseq method 'xy' makes numpy interop easier"""
+    def test_point(self):
+        g = geometry.Point(0, 1)
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'Point')
+        self.failUnlessEqual(list(h.coords), [(1.0, 2.0)])
+    def test_line(self):
+        g = geometry.LineString(((0, 1), (2, 3)))
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'LineString')
+        self.failUnlessEqual(list(h.coords), [(1.0, 2.0), (3.0, 4.0)])
+    def test_polygon(self):
+        g = geometry.Point(0, 1).buffer(1.0)
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'Polygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+        self.failUnlessAlmostEqual(h.centroid.x, 1.0)
+        self.failUnlessAlmostEqual(h.centroid.y, 2.0)
+    def test_multipolygon(self):
+        g = geometry.MultiPoint([(0, 1), (0, 4)]).buffer(1.0)
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'MultiPolygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+        self.failUnlessAlmostEqual(h.centroid.x, 1.0)
+        self.failUnlessAlmostEqual(h.centroid.y, 3.5)
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        unittest.TestLoader().loadTestsFromTestCase(IdentityTestCase),
+        unittest.TestLoader().loadTestsFromTestCase(LambdaTestCase)])