rgeo-dschee 0.5.4

data/test/geos_ffi/geometry_collection_test.rb

@@ -0,0 +1,24 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS geometry collection implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/geometry_collection_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosFFI # :nodoc:
+      class TestGeometryCollection < ::Test::Unit::TestCase # :nodoc:
+        def create_factory
+          ::RGeo::Geos.factory(native_interface: :ffi)
+        end
+
+        include ::RGeo::Tests::Common::GeometryCollectionTests
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/line_string_test.rb

@@ -0,0 +1,24 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS line string implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/line_string_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosFFI # :nodoc:
+      class TestLineString < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory(native_interface: :ffi)
+        end
+
+        include ::RGeo::Tests::Common::LineStringTests
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/misc_test.rb

@@ -0,0 +1,63 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for miscellaneous GEOS stuff
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosFFI # :nodoc:
+      class TestMisc < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory(srid: 4326, native_interface: :ffi)
+        end
+
+        def test_empty_geometries_equal
+          geom1_ = @factory.collection([])
+          geom2_ = @factory.line_string([])
+          assert(!geom1_.eql?(geom2_))
+          assert(geom1_.equals?(geom2_))
+        end
+
+        def test_prepare
+          p1_ = @factory.point(1, 2)
+          p2_ = @factory.point(3, 4)
+          p3_ = @factory.point(5, 2)
+          polygon_ = @factory.polygon(@factory.linear_ring([p1_, p2_, p3_, p1_]))
+          assert_equal(false, polygon_.prepared?)
+          polygon_.prepare!
+          assert_equal(true, polygon_.prepared?)
+        end
+
+        def test_auto_prepare
+          p1_ = @factory.point(1, 2)
+          p2_ = @factory.point(3, 4)
+          p3_ = @factory.point(5, 2)
+          polygon_ = @factory.polygon(@factory.linear_ring([p1_, p2_, p3_, p1_]))
+          assert_equal(false, polygon_.prepared?)
+          polygon_.intersects?(p1_)
+          assert_equal(false, polygon_.prepared?)
+          polygon_.intersects?(p2_)
+          assert_equal(true, polygon_.prepared?)
+
+          factory_no_auto_prepare_ = ::RGeo::Geos.factory(srid: 4326,
+                                                          native_interface: :ffi, auto_prepare: :disabled)
+          polygon2_ = factory_no_auto_prepare_.polygon(
+            factory_no_auto_prepare_.linear_ring([p1_, p2_, p3_, p1_]))
+          assert_equal(false, polygon2_.prepared?)
+          polygon2_.intersects?(p1_)
+          assert_equal(false, polygon2_.prepared?)
+          polygon2_.intersects?(p2_)
+          assert_equal(false, polygon2_.prepared?)
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?
+
+unless ::RGeo::Geos.ffi_supported?
+  puts "WARNING: FFI-GEOS support not available. Related tests skipped."
+end

data/test/geos_ffi/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 GeosFFI # :nodoc:
+      class TestMultiLineString < ::Test::Unit::TestCase # :nodoc:
+        def create_factory
+          ::RGeo::Geos.factory(native_interface: :ffi)
+        end
+
+        include ::RGeo::Tests::Common::MultiLineStringTests
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/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 GeosFFI # :nodoc:
+      class TestMultiPoint < ::Test::Unit::TestCase # :nodoc:
+        def create_factory(opts_ = {})
+          ::RGeo::Geos.factory(opts_.merge(native_interface: :ffi))
+        end
+
+        include ::RGeo::Tests::Common::MultiPointTests
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/multi_polygon_test.rb

@@ -0,0 +1,33 @@
+# -----------------------------------------------------------------------------
+#
+# 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 GeosFFI # :nodoc:
+      class TestMultiPolygon < ::Test::Unit::TestCase # :nodoc:
+        def create_factories
+          @factory = ::RGeo::Geos.factory(native_interface: :ffi)
+          @lenient_factory = ::RGeo::Geos.factory(lenient_multi_polygon_assertions: true,
+                                                  native_interface: :ffi)
+        end
+
+        include ::RGeo::Tests::Common::MultiPolygonTests
+
+        # Centroid of an empty should return an empty collection
+        # rather than throw a weird exception out of ffi-geos
+
+        def test_empty_centroid
+          assert_equal(@factory.collection([]), @factory.multi_polygon([]).centroid)
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/parsing_unparsing_test.rb

@@ -0,0 +1,41 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+module RGeo
+  module Tests # :nodoc:
+    module GeosFFI # :nodoc:
+      class TestParsingUnparsing < ::Test::Unit::TestCase # :nodoc:
+        def test_wkt_generator_default_floating_point
+          # Bug report GH-4
+          factory_ = ::RGeo::Geos.factory(native_interface: :ffi)
+          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 },
+                                          native_interface: :ffi)
+          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, native_interface: :ffi)
+          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(native_interface: :ffi)
+          assert_not_nil(factory_.parse_wkt("Point (1 1)"))
+        end
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/point_test.rb

@@ -0,0 +1,77 @@
+# -----------------------------------------------------------------------------
+#
+# 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 GeosFFI # :nodoc:
+      class TestPoint < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory(native_interface: :ffi, buffer_resolution: 8)
+          @zfactory = ::RGeo::Geos.factory(has_z_coordinate: true, native_interface: :ffi)
+          @mfactory = ::RGeo::Geos.factory(has_m_coordinate: true, native_interface: :ffi)
+          @zmfactory = ::RGeo::Geos.factory(has_z_coordinate: true, has_m_coordinate: true,
+                                            native_interface: :ffi)
+        end
+
+        include ::RGeo::Tests::Common::PointTests
+
+        # TEMP until ffi-geos 0.0.5 is released
+        undef_method :test_buffer
+        # END_TEMP
+
+        def test_is_geos
+          point_ = @factory.point(21, -22)
+          assert_equal(true, ::RGeo::Geos.is_geos?(point_))
+          assert_equal(false, ::RGeo::Geos.is_capi_geos?(point_))
+          assert_equal(true, ::RGeo::Geos.is_ffi_geos?(point_))
+          point2_ = @zmfactory.point(21, -22, 0, 0)
+          assert_equal(true, ::RGeo::Geos.is_geos?(point2_))
+          assert_equal(false, ::RGeo::Geos.is_capi_geos?(point2_))
+          assert_equal(true, ::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(native_interface: :ffi, 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(native_interface: :ffi, 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.ffi_supported?

data/test/geos_ffi/polygon_test.rb

@@ -0,0 +1,46 @@
+# -----------------------------------------------------------------------------
+#
+# 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 GeosFFI # :nodoc:
+      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geos.factory(native_interface: :ffi)
+        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
+      end
+    end
+  end
+end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/zmfactory_test.rb

@@ -0,0 +1,58 @@
+# -----------------------------------------------------------------------------
+#
+# 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 GeosFFI # :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, 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
+
+        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.ffi_supported?

data/test/mixins_test.rb

@@ -0,0 +1,141 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for mixin system
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+module RGeo
+  module Tests # :nodoc:
+    class TestMixins < ::Test::Unit::TestCase # :nodoc:
+      module Mixin1  # :nodoc:
+        def mixin1_method
+        end
+      end
+
+      module Mixin2  # :nodoc:
+        def mixin2_method
+        end
+      end
+
+      ::RGeo::Feature::MixinCollection::GLOBAL.for_type(::RGeo::Feature::Point).add(Mixin1)
+      ::RGeo::Feature::MixinCollection::GLOBAL.for_type(::RGeo::Feature::GeometryCollection).add(Mixin1)
+      ::RGeo::Feature::MixinCollection::GLOBAL.for_type(::RGeo::Feature::MultiCurve).add(Mixin2)
+
+      def test_basic_mixin_cartesian
+        factory_ = ::RGeo::Cartesian.simple_factory
+        assert_equal(::RGeo::Cartesian::PointImpl, factory_.point(1, 1).class)
+        assert(factory_.point(1, 1).class.include?(Mixin1))
+        assert(!factory_.point(1, 1).class.include?(Mixin2))
+        assert(factory_.point(1, 1).respond_to?(:mixin1_method))
+        assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
+      end
+
+      def test_inherited_mixin_cartesian
+        factory_ = ::RGeo::Cartesian.simple_factory
+        assert(factory_.collection([]).class.include?(Mixin1))
+        assert(!factory_.collection([]).class.include?(Mixin2))
+        assert(factory_.collection([]).respond_to?(:mixin1_method))
+        assert(!factory_.collection([]).respond_to?(:mixin2_method))
+        assert(factory_.multi_line_string([]).class.include?(Mixin1))
+        assert(factory_.multi_line_string([]).class.include?(Mixin2))
+        assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
+        assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
+      end
+
+      if ::RGeo::Geos.capi_supported?
+
+        def test_basic_mixin_geos_capi
+          factory_ = ::RGeo::Geos.factory(native_interface: :capi)
+          assert_equal(::RGeo::Geos::CAPIPointImpl, factory_.point(1, 1).class)
+          assert(factory_.point(1, 1).class.include?(Mixin1))
+          assert(!factory_.point(1, 1).class.include?(Mixin2))
+          assert(factory_.point(1, 1).respond_to?(:mixin1_method))
+          assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
+        end
+
+        def test_inherited_mixin_geos_capi
+          factory_ = ::RGeo::Geos.factory(native_interface: :capi)
+          assert(factory_.collection([]).class.include?(Mixin1))
+          assert(!factory_.collection([]).class.include?(Mixin2))
+          assert(factory_.collection([]).respond_to?(:mixin1_method))
+          assert(!factory_.collection([]).respond_to?(:mixin2_method))
+          assert(factory_.multi_line_string([]).class.include?(Mixin1))
+          assert(factory_.multi_line_string([]).class.include?(Mixin2))
+          assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
+          assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
+        end
+
+      end
+
+      if ::RGeo::Geos.ffi_supported?
+
+        def test_basic_mixin_geos_ffi
+          factory_ = ::RGeo::Geos.factory(native_interface: :ffi)
+          assert_equal(::RGeo::Geos::FFIPointImpl, factory_.point(1, 1).class)
+          assert(factory_.point(1, 1).class.include?(Mixin1))
+          assert(!factory_.point(1, 1).class.include?(Mixin2))
+          assert(factory_.point(1, 1).respond_to?(:mixin1_method))
+          assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
+        end
+
+        def test_inherited_mixin_geos_ffi
+          factory_ = ::RGeo::Geos.factory(native_interface: :ffi)
+          assert(factory_.collection([]).class.include?(Mixin1))
+          assert(!factory_.collection([]).class.include?(Mixin2))
+          assert(factory_.collection([]).respond_to?(:mixin1_method))
+          assert(!factory_.collection([]).respond_to?(:mixin2_method))
+          assert(factory_.multi_line_string([]).class.include?(Mixin1))
+          assert(factory_.multi_line_string([]).class.include?(Mixin2))
+          assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
+          assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
+        end
+
+      end
+
+      def test_basic_mixin_spherical
+        factory_ = ::RGeo::Geographic.spherical_factory
+        assert_equal(::RGeo::Geographic::SphericalPointImpl, factory_.point(1, 1).class)
+        assert(factory_.point(1, 1).class.include?(Mixin1))
+        assert(!factory_.point(1, 1).class.include?(Mixin2))
+        assert(factory_.point(1, 1).respond_to?(:mixin1_method))
+        assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
+      end
+
+      def test_inherited_mixin_spherical
+        factory_ = ::RGeo::Geographic.spherical_factory
+        assert(factory_.collection([]).class.include?(Mixin1))
+        assert(!factory_.collection([]).class.include?(Mixin2))
+        assert(factory_.collection([]).respond_to?(:mixin1_method))
+        assert(!factory_.collection([]).respond_to?(:mixin2_method))
+        assert(factory_.multi_line_string([]).class.include?(Mixin1))
+        assert(factory_.multi_line_string([]).class.include?(Mixin2))
+        assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
+        assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
+      end
+
+      def test_basic_mixin_simple_mercator
+        factory_ = ::RGeo::Geographic.simple_mercator_factory
+        assert_equal(::RGeo::Geographic::ProjectedPointImpl, factory_.point(1, 1).class)
+        assert(factory_.point(1, 1).class.include?(Mixin1))
+        assert(!factory_.point(1, 1).class.include?(Mixin2))
+        assert(factory_.point(1, 1).respond_to?(:mixin1_method))
+        assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
+      end
+
+      def test_inherited_mixin_simple_mercator
+        factory_ = ::RGeo::Geographic.simple_mercator_factory
+        assert(factory_.collection([]).class.include?(Mixin1))
+        assert(!factory_.collection([]).class.include?(Mixin2))
+        assert(factory_.collection([]).respond_to?(:mixin1_method))
+        assert(!factory_.collection([]).respond_to?(:mixin2_method))
+        assert(factory_.multi_line_string([]).class.include?(Mixin1))
+        assert(factory_.multi_line_string([]).class.include?(Mixin2))
+        assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
+        assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
+      end
+    end
+  end
+end