rgeo-dschee 0.5.4

data/test/geos_capi/multi_line_string_test.rb

@@ -0,0 +1,24 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS multi line string implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_line_string_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosCAPI # :nodoc:
+      class TestMultiLineString < ::Test::Unit::TestCase # :nodoc:
+        def create_factory
+          ::RGeo::Geos.factory
+        end
+
+        include ::RGeo::Tests::Common::MultiLineStringTests
+      end
+    end
+  end
+end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/multi_point_test.rb

@@ -0,0 +1,24 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS multi point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_point_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosCAPI # :nodoc:
+      class TestMultiPoint < ::Test::Unit::TestCase # :nodoc:
+        def create_factory(opts_ = {})
+          ::RGeo::Geos.factory(opts_)
+        end
+
+        include ::RGeo::Tests::Common::MultiPointTests
+      end
+    end
+  end
+end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/multi_polygon_test.rb

@@ -0,0 +1,39 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS multi polygon implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_polygon_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosCAPI # :nodoc:
+      class TestMultiPolygon < ::Test::Unit::TestCase # :nodoc:
+        def create_factories
+          @factory = ::RGeo::Geos.factory
+          @lenient_factory = ::RGeo::Geos.factory(lenient_multi_polygon_assertions: true)
+        end
+
+        include ::RGeo::Tests::Common::MultiPolygonTests
+
+        # Centroid of an empty should return an empty collection rather than crash
+
+        def test_empty_centroid
+          assert_equal(@factory.collection([]), @factory.multi_polygon([]).centroid)
+        end
+
+        def _test_geos_bug_582
+          f_ = ::RGeo::Geos.factory(buffer_resolution: 2)
+          p1_ = f_.polygon(f_.linear_ring([]))
+          p2_ = f_.polygon(f_.linear_ring([f_.point(0, 0), f_.point(0, 1), f_.point(1, 1), f_.point(1, 0)]))
+          mp_ = f_.multi_polygon([p2_, p1_])
+          mp_.centroid.as_text
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/parsing_unparsing_test.rb

@@ -0,0 +1,40 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosCAPI # :nodoc:
+      class TestParsingUnparsing < ::Test::Unit::TestCase # :nodoc:
+        def test_wkt_generator_default_floating_point
+          # Bug report GH-4
+          factory_ = ::RGeo::Geos.factory
+          point_ = factory_.point(111.99, -40.37)
+          assert_equal("POINT (111.99 -40.37)", point_.as_text)
+        end
+
+        def test_wkt_generator_downcase
+          factory_ = ::RGeo::Geos.factory(wkt_generator: { convert_case: :lower })
+          point_ = factory_.point(1, 1)
+          assert_equal("point (1.0 1.0)", point_.as_text)
+        end
+
+        def test_wkt_generator_geos
+          factory_ = ::RGeo::Geos.factory(wkt_generator: :geos)
+          point_ = factory_.point(1, 1)
+          assert_equal("POINT (1.0000000000000000 1.0000000000000000)", point_.as_text)
+        end
+
+        def test_wkt_parser_default_with_non_geosable_input
+          factory_ = ::RGeo::Geos.factory
+          assert_not_nil(factory_.parse_wkt("Point (1 1)"))
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/point_test.rb

@@ -0,0 +1,72 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/point_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosCAPI # :nodoc:
+      class TestPoint < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory(buffer_resolution: 8)
+          @zfactory = ::RGeo::Geos.factory(has_z_coordinate: true)
+          @mfactory = ::RGeo::Geos.factory(has_m_coordinate: true)
+          @zmfactory = ::RGeo::Geos.factory(has_z_coordinate: true, has_m_coordinate: true)
+        end
+
+        include ::RGeo::Tests::Common::PointTests
+
+        def test_is_geos
+          point_ = @factory.point(21, -22)
+          assert_equal(true, ::RGeo::Geos.is_geos?(point_))
+          assert_equal(true, ::RGeo::Geos.is_capi_geos?(point_))
+          assert_equal(false, ::RGeo::Geos.is_ffi_geos?(point_))
+          point2_ = @zmfactory.point(21, -22, 0, 0)
+          assert_equal(true, ::RGeo::Geos.is_geos?(point2_))
+          assert_equal(true, ::RGeo::Geos.is_capi_geos?(point2_))
+          assert_equal(false, ::RGeo::Geos.is_ffi_geos?(point2_))
+        end
+
+        def test_has_no_projection
+          point_ = @factory.point(21, -22)
+          assert(!point_.respond_to?(:projection))
+        end
+
+        def test_srid
+          point_ = @factory.point(11, 12)
+          assert_equal(0, point_.srid)
+        end
+
+        def test_distance
+          point1_ = @factory.point(11, 12)
+          point2_ = @factory.point(11, 12)
+          point3_ = @factory.point(13, 12)
+          assert_equal(0, point1_.distance(point2_))
+          assert_equal(2, point1_.distance(point3_))
+        end
+
+        if defined?(::Encoding)
+
+          def test_as_text_encoding
+            factory_ = ::RGeo::Geos.factory(wkt_generator: :geos)
+            point_ = factory_.point(11, 12)
+            assert_equal(::Encoding::US_ASCII, point_.as_text.encoding)
+          end
+
+          def test_as_binary_encoding
+            factory_ = ::RGeo::Geos.factory(wkb_generator: :geos)
+            point_ = factory_.point(11, 12)
+            assert_equal(::Encoding::ASCII_8BIT, point_.as_binary.encoding)
+          end
+
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/polygon_test.rb

@@ -0,0 +1,154 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS polygon implementation
+#
+# -----------------------------------------------------------------------------
+
+require 'test/unit'
+require 'rgeo'
+
+require ::File.expand_path('../common/polygon_tests.rb', ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosCAPI # :nodoc:
+      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory
+        end
+
+        include ::RGeo::Tests::Common::PolygonTests
+
+        def test_intersection
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 2)
+          point3_ = @factory.point(2, 2)
+          point4_ = @factory.point(2, 0)
+          poly1_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point3_, point4_]))
+          poly2_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point4_]))
+          poly3_ = poly1_.intersection(poly2_)
+          assert_equal(poly2_, poly3_)
+        end
+
+        def test_union
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 2)
+          point3_ = @factory.point(2, 2)
+          point4_ = @factory.point(2, 0)
+          poly1_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point3_, point4_]))
+          poly2_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point4_]))
+          poly3_ = poly1_.union(poly2_)
+          assert_equal(poly1_, poly3_)
+        end
+
+        def test_simplify
+          xys = [[0, 0], [5, 0], [10, 0], [10, 10], [5, 10.2], [0, 10], [0, 0]]
+          points = xys.collect { |x, y| @factory.point(x, y) }
+          poly = @factory.polygon(@factory.linear_ring(points))
+          simplified = poly.simplify(0.3)
+          new_points = simplified.exterior_ring.points
+          extra = new_points.reject { |p| [0, 10].include?(p.x) and [0, 10].include?(p.y) }
+          assert_equal 5, new_points.length, "Closed ring of the square should have 5 points"
+          assert_equal 0, extra.length, "Should only have x/y's on 0 and 10"
+        end
+
+        def test_buffer
+          polygon_coordinates = [[0.5527864045000421, 3.776393202250021],
+                                 [0.7763932022500211, 4.447213595499958],
+                                 [1.4472135954999579, 4.223606797749979],
+                                 [2.447213595499958, 2.223606797749979],
+                                 [2.223606797749979, 1.5527864045000421],
+                                 [1.5527864045000421, 1.776393202250021],
+                                 [0.5527864045000421, 3.776393202250021]]
+
+          points_arr = polygon_coordinates.map { |v| @factory.point(v[0], v[1]) }
+          outer_ring = @factory.linear_ring(points_arr)
+          polygon = @factory.polygon(outer_ring)
+
+          point1 = @factory.point(2, 2)
+          point2 = @factory.point(1, 4)
+          line_string = @factory.line_string([point1, point2])
+          polygon2 = line_string.buffer(0.5)
+
+          assert_equal polygon, polygon2
+        end
+
+        def test_simplify_preserve_topology()
+          xys1 = [[0.0, 0.0], [5.0, 0.0], [10.0, 0.0], [10.0, 10.0], [5.0, 12.0], [0.0, 10.0], [0.0, 0.0]]
+          xys2 = [[0.1, 0.1], [0.1, 0.6], [0.3, 0.8],  [0.5, 0.5],   [0.7, 0.3],  [0.3, 0.1],  [0.1, 0.1]]
+          
+          points1 = xys1.collect { |x,y| @factory.point(x, y) }
+          points2 = xys2.collect { |x,y| @factory.point(x, y) }
+          
+          ln1 = @factory.line_string(points1)
+          ln2 = @factory.line_string(points2)
+
+          poly = @factory.polygon(ln1,[ln2])
+
+          simplified = poly.simplify_preserve_topology(1)
+          interior_points = simplified.interior_rings[0].points
+
+          assert_equal 5, interior_points.length
+        end
+
+        def test_buffer_with_style
+          polygon_coordinates = [[0.7316718427000253, 3.865835921350013],
+                                 [1.0, 4.3], [6.0, 4.3], [6.3, 4.3],
+                                 [6.3, 3.7], [1.4854101966249682, 3.7],
+                                 [2.2683281572999747, 2.134164078649987],
+                                 [2.4024922359499623, 1.8658359213500124],
+                                 [1.8658359213500126, 1.597507764050038],
+                                 [0.7316718427000253, 3.865835921350013]]
+
+          points_arr = polygon_coordinates.map { |v| @factory.point(v[0], v[1]) }
+          outer_ring = @factory.linear_ring(points_arr)
+          polygon = @factory.polygon(outer_ring)
+
+          point1 = @factory.point(2, 2)
+          point2 = @factory.point(1, 4)
+          point3 = @factory.point(6, 4)
+          line_string = @factory.line_string([point1, point2, point3])
+          buffered_line_string = line_string.buffer_with_style(0.3,
+                                                                 RGeo::Geos::CAP_FLAT,
+                                                                 RGeo::Geos::JOIN_ROUND,
+                                                                 0.0)
+
+          assert_equal polygon, buffered_line_string
+        end
+
+        def test_is_valid_polygon
+          polygon_coordinates = [[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]]
+          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
+          outer_ring = @factory.linear_ring(points_arr)
+          polygon = @factory.polygon(outer_ring)
+          
+          assert_equal(polygon.valid?, true)
+                               
+          polygon_coordinates  = [[-1, -1], [-1, 0], [1, 0], [1, 1], [0, 1], [0, -1], [-1, -1]]
+          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
+          outer_ring = @factory.linear_ring(points_arr)
+          polygon = @factory.polygon(outer_ring)
+          
+          assert_equal(polygon.valid?, false)
+        end
+
+        def test_invalid_reason
+          polygon_coordinates  = [[-1, -1], [-1, 0], [1, 0], [1, 1], [0, 1], [0, -1], [-1, -1]]
+          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
+          outer_ring = @factory.linear_ring(points_arr)
+          polygon = @factory.polygon(outer_ring)
+
+          assert_equal(polygon.invalid_reason, "Self-intersection[0 0 0]")  
+        end
+
+        def test_invalid_reason_with_valid_polygon
+          polygon_coordinates = [[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]]
+          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
+          outer_ring = @factory.linear_ring(points_arr)
+          polygon = @factory.polygon(outer_ring)
+          polygon.invalid_reason
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/zmfactory_test.rb

@@ -0,0 +1,57 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/factory_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosCAPI # :nodoc:
+      class TestZMFactory < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory(has_z_coordinate: true, has_m_coordinate: true, srid: 1000, buffer_resolution: 2)
+          @srid = 1000
+        end
+
+        include ::RGeo::Tests::Common::FactoryTests
+
+        def test_is_geos_factory
+          assert_equal(true, ::RGeo::Geos.is_geos?(@factory))
+          assert_equal(true, ::RGeo::Geos.is_capi_geos?(@factory))
+          assert_equal(false, ::RGeo::Geos.is_ffi_geos?(@factory))
+        end
+
+        def test_factory_parts
+          assert_equal(1000, @factory.srid)
+          assert_equal(1000, @factory.z_factory.srid)
+          assert_equal(1000, @factory.m_factory.srid)
+          assert_equal(2, @factory.buffer_resolution)
+          assert_equal(2, @factory.z_factory.buffer_resolution)
+          assert_equal(2, @factory.m_factory.buffer_resolution)
+          assert(@factory.property(:has_z_coordinate))
+          assert(@factory.property(:has_m_coordinate))
+          assert(@factory.z_factory.property(:has_z_coordinate))
+          assert(!@factory.z_factory.property(:has_m_coordinate))
+          assert(!@factory.m_factory.property(:has_z_coordinate))
+          assert(@factory.m_factory.property(:has_m_coordinate))
+        end
+
+        def test_4d_point
+          point_ = @factory.point(1, 2, 3, 4)
+          assert_equal(Feature::Point, point_.geometry_type)
+          assert_equal(3, point_.z)
+          assert_equal(4, point_.m)
+          assert_equal(3, point_.z_geometry.z)
+          assert_nil(point_.z_geometry.m)
+          assert_nil(point_.m_geometry.z)
+          assert_equal(4, point_.m_geometry.m)
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.capi_supported?

data/test/geos_ffi/factory_test.rb

@@ -0,0 +1,31 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS factory
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/factory_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosFFI # :nodoc:
+      class TestFactory < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory(srid: 1000, native_interface: :ffi)
+          @srid = 1000
+        end
+
+        include ::RGeo::Tests::Common::FactoryTests
+
+        def test_is_geos_factory
+          assert_equal(true, ::RGeo::Geos.is_geos?(@factory))
+          assert_equal(false, ::RGeo::Geos.is_capi_geos?(@factory))
+          assert_equal(true, ::RGeo::Geos.is_ffi_geos?(@factory))
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?