ffi-geos 0.0.1.beta1

data/test/misc_tests.rb

@@ -0,0 +1,53 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class MiscTests < Test::Unit::TestCase
+  include TestHelper
+
+  def thread_tester(name, dims, byte_order, polygon, pause)
+    msg = proc { |*args| @messages << "#{name}: #{args.inspect}" }
+
+    3.times {
+      sleep(pause)
+      wktr = Geos::WktReader.new
+      wkbw = Geos::WkbWriter.new
+      wkbw.byte_order = byte_order
+      wkbw.output_dimensions = dims
+      geom = wktr.read(polygon)
+      msg[geom.valid?]
+      msg[wkbw.write_hex(geom)]
+      GC.start
+    }
+  end
+
+  def test_multithreading
+    @messages = []
+
+    t1 = Thread.new {
+      thread_tester('t1', 2, 0, 'POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))', 0.2)
+    }
+
+    t2 = Thread.new {
+      thread_tester('t2', 3, 1, 'POLYGON((0 0 0, 0 5 0, 5 5 0, 5 10 0, 0 0 0))', 0.1)
+    }
+
+    t1.join
+    t2.join
+
+    assert_equal([
+      "t1: [\"000000000300000001000000050000000000000000000000000000000000000000000000004014000000000000401400000000000040140000000000004014000000000000000000000000000000000000000000000000000000000000\"]",
+      "t1: [\"000000000300000001000000050000000000000000000000000000000000000000000000004014000000000000401400000000000040140000000000004014000000000000000000000000000000000000000000000000000000000000\"]",
+      "t1: [\"000000000300000001000000050000000000000000000000000000000000000000000000004014000000000000401400000000000040140000000000004014000000000000000000000000000000000000000000000000000000000000\"]",
+      "t1: [true]",
+      "t1: [true]",
+      "t1: [true]",
+      "t2: [\"01030000800100000005000000000000000000000000000000000000000000000000000000000000000000000000000000000014400000000000000000000000000000144000000000000014400000000000000000000000000000144000000000000024400000000000000000000000000000000000000000000000000000000000000000\"]",
+      "t2: [\"01030000800100000005000000000000000000000000000000000000000000000000000000000000000000000000000000000014400000000000000000000000000000144000000000000014400000000000000000000000000000144000000000000024400000000000000000000000000000000000000000000000000000000000000000\"]",
+      "t2: [\"01030000800100000005000000000000000000000000000000000000000000000000000000000000000000000000000000000014400000000000000000000000000000144000000000000014400000000000000000000000000000144000000000000024400000000000000000000000000000000000000000000000000000000000000000\"]",
+      "t2: [false]",
+      "t2: [false]",
+      "t2: [false]"
+    ], @messages.sort)
+  end
+end

data/test/point_tests.rb

@@ -0,0 +1,31 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class PointTests < Test::Unit::TestCase
+  include TestHelper
+
+  def test_default_srid
+    geom = read('POINT(0 0)')
+    assert_equal(0, geom.srid)
+  end
+
+  def test_setting_srid_manually
+    geom = read('POINT(0 0)')
+    geom.srid = 4326
+    assert_equal(4326, geom.srid)
+  end
+
+  def test_dimensions
+    geom = read('POINT(1 2)')
+    assert_equal(0, geom.dimensions)
+
+    geom = read('POINT(1 2 3)')
+    assert_equal(0, geom.dimensions)
+  end
+
+  def test_num_geometries
+    geom = read('POINT(1 2)')
+    assert_equal(1, geom.num_geometries)
+  end
+end

data/test/prepared_geometry_tests.rb

@@ -0,0 +1,28 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+if defined?(Geos::PreparedGeometry)
+  class PreparedGeometryTests < Test::Unit::TestCase
+    include TestHelper
+
+    def test_contains_properly
+      geom_a = read('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))').to_prepared
+      geom_b = read('POLYGON((2 2, 2 3, 3 3, 3 2, 2 2))')
+
+      assert(geom_a.contains_properly?(geom_b))
+
+      geom_a = read('POLYGON((2 2, 2 3, 3 3, 3 2, 2 2))').to_prepared
+      geom_b = read('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))')
+
+      assert(!geom_a.contains_properly?(geom_b))
+    end
+
+    def test_intersects
+      geom_a = read('LINESTRING(0 0, 10 10)').to_prepared
+      geom_b = read('LINESTRING(0 10, 10 0)')
+
+      assert(geom_a.intersects?(geom_b))
+    end
+  end
+end

data/test/strtree_tests.rb

@@ -0,0 +1,54 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+if defined?(Geos::STRtree)
+  class STRtreeTests < Test::Unit::TestCase
+    include TestHelper
+
+    def setup_tree
+      @tree = Geos::STRtree.new(3)
+      @item_1 = { :item_1 => :test }
+      @item_2 = [ :test ]
+      @item_3 = Object.new
+
+      @geom_1 = read('LINESTRING(0 0, 10 10)')
+      @geom_2 = read('LINESTRING(20 20, 30 30)')
+      @geom_3 = read('LINESTRING(20 20, 30 30)')
+
+      @tree.insert(@geom_1, @item_1)
+      @tree.insert(@geom_2, @item_2)
+      @tree.insert(@geom_3, @item_3)
+    end
+
+    def test_disallowed_inserts
+      setup_tree
+
+      @tree.query(read('POINT(5 5)'))
+
+      assert_raise(RuntimeError) do
+        @tree.insert(read('POINT(0 0)'), 'test')
+      end
+    end
+
+    def test_query
+      setup_tree
+
+      assert_equal(1, @tree.query(read('LINESTRING(5 5, 6 6)')).length)
+      assert_equal(0, @tree.query(read('LINESTRING(20 0, 30 10)')).length)
+      assert_equal(2, @tree.query(read('LINESTRING(25 25, 26 26)')).length)
+      assert_equal(3, @tree.query(read('LINESTRING(0 0, 100 100)')).length)
+    end
+
+    def test_remove
+      setup_tree
+
+      @tree.remove(read('POINT(5 5)'), @item_1)
+
+      assert_equal(0, @tree.query(read('LINESTRING(5 5, 6 6)')).length)
+      assert_equal(0, @tree.query(read('LINESTRING(20 0, 30 10)')).length)
+      assert_equal(2, @tree.query(read('LINESTRING(25 25, 26 26)')).length)
+      assert_equal(2, @tree.query(read('LINESTRING(0 0, 100 100)')).length)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,40 @@
+
+require 'rubygems'
+require 'test/unit'
+
+if ENV['USE_BINARY_GEOS']
+  require 'geos'
+else
+  require File.join(File.dirname(__FILE__), %w{ .. lib ffi-geos })
+end
+
+puts "Ruby version #{RUBY_VERSION} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
+puts "GEOS version #{Geos::GEOS_VERSION}"
+puts "ffi-geos version #{Geos::VERSION}" if defined?(Geos::VERSION)
+if defined?(Geos::FFIGeos)
+  puts "Using #{Geos::FFIGeos.geos_library_paths.join(', ')}"
+end
+
+module TestHelper
+  TOLERANCE = 0.0000000000001
+
+  def self.included(base)
+    base.class_eval do
+      attr_reader :reader, :writer
+    end
+  end
+
+  def setup
+    GC.start
+    @reader = Geos::WktReader.new
+    @writer = Geos::WktWriter.new
+  end
+
+  def read(*args)
+    reader.read(*args)
+  end
+
+  def write(*args)
+    writer.write(*args)
+  end
+end

data/test/utils_tests.rb

@@ -0,0 +1,333 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class UtilsTests < Test::Unit::TestCase
+  include TestHelper
+
+  if defined?(Geos::Utils)
+    if Geos::Utils.respond_to?(:orientation_index)
+      def test_orientation_index
+        assert_equal(0,  Geos::Utils.orientation_index(0, 0, 10, 0, 5, 0))
+        assert_equal(0,  Geos::Utils.orientation_index(0, 0, 10, 0, 10, 0))
+        assert_equal(0,  Geos::Utils.orientation_index(0, 0, 10, 0, 0, 0))
+        assert_equal(0,  Geos::Utils.orientation_index(0, 0, 10, 0, -5, 0))
+        assert_equal(0,  Geos::Utils.orientation_index(0, 0, 10, 0, 20, 0))
+        assert_equal(1,  Geos::Utils.orientation_index(0, 0, 10, 10, 5, 6))
+        assert_equal(1,  Geos::Utils.orientation_index(0, 0, 10, 10, 5, 20))
+        assert_equal(-1,  Geos::Utils.orientation_index(0, 0, 10, 10, 5, 3))
+        assert_equal(-1,  Geos::Utils.orientation_index(0, 0, 10, 10, 5, -2))
+        assert_equal(1,  Geos::Utils.orientation_index(0, 0, 10, 10, 1000000, 1000001))
+        assert_equal(-1,  Geos::Utils.orientation_index(0, 0, 10, 10, 1000000,  999999))
+      end
+    end
+
+    if Geos::Utils.respond_to?(:relate_match)
+      def test_relate_match
+        assert(Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFF2'))
+        assert(Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFF*'))
+        assert(Geos::Utils.relate_match('0FFFFFFF2', 'TFFFFFFF2'))
+        assert(!Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFFF'))
+      end
+    end
+  end
+
+  def create_method_tester(expected, method, cs, type_id, klass)
+    geom = Geos.send(method, cs)
+    expected_geom = read(expected)
+
+    assert(expected_geom.eql_exact?(geom, TOLERANCE))
+    assert(geom.valid?)
+    assert_instance_of(klass, geom)
+    assert_equal(type_id, geom.type_id)
+
+    yield geom if block_given?
+  end
+
+  def test_create_point
+    cs = Geos::CoordinateSequence.new(1, 2)
+    cs.set_x(0, 10)
+    cs.set_y(0, 20)
+
+    create_method_tester('POINT(10 20)', :create_point, cs, Geos::GEOS_POINT, Geos::Point)
+  end
+
+  def test_bad_create_point
+    cs = Geos::CoordinateSequence.new(0, 0)
+    assert_raise(RuntimeError) do
+      geom = Geos.create_point(cs)
+    end
+  end
+
+  def test_create_line_string
+    cs = Geos::CoordinateSequence.new(2, 3)
+    cs.set_x(0, 10)
+    cs.set_y(0, 20)
+    cs.set_z(0, 30)
+    cs.set_x(1, 30)
+    cs.set_y(1, 20)
+    cs.set_z(1, 10)
+
+    create_method_tester(
+      'LINESTRING (10 20 30, 30 20 10)',
+      :create_line_string,
+      cs,
+      Geos::GEOS_LINESTRING,
+      Geos::LineString
+    ) do |geom|
+      assert(!geom.empty?)
+      assert(geom.valid?)
+      assert(geom.simple?)
+      assert(!geom.ring?)
+      assert(geom.has_z?)
+      assert_equal(1, geom.num_geometries)
+    end
+  end
+
+  def test_create_bad_line_string
+    cs = Geos::CoordinateSequence.new(1, 0)
+    assert_raise(RuntimeError) do
+      geom = Geos::create_line_string(cs)
+    end
+  end
+
+  def test_create_linear_ring
+    cs = Geos::CoordinateSequence.new(4,3)
+    cs.set_x(0, 7)
+    cs.set_y(0, 8)
+    cs.set_z(0, 9)
+    cs.set_x(1, 3)
+    cs.set_y(1, 3)
+    cs.set_z(1, 3)
+    cs.set_x(2, 11)
+    cs.set_y(2, 15.2)
+    cs.set_z(2, 2)
+    cs.set_x(3, 7)
+    cs.set_y(3, 8)
+    cs.set_z(3, 9)
+
+    create_method_tester(
+      'LINEARRING (7 8 9, 3 3 3, 11 15.2 2, 7 8 9)',
+      :create_linear_ring,
+      cs,
+      Geos::GEOS_LINEARRING,
+      Geos::LinearRing
+    ) do |geom|
+      assert(!geom.empty?)
+      assert(geom.valid?)
+      assert(geom.simple?)
+      assert(geom.ring?)
+      assert(geom.has_z?)
+      assert_equal(1, geom.num_geometries)
+    end
+  end
+
+  def test_bad_create_linear_ring
+    cs = Geos::CoordinateSequence.new(1, 0)
+
+    assert_raise(RuntimeError) do
+      geom = Geos::create_linear_ring(cs)
+    end
+  end
+
+  def test_create_polygon
+    cs = Geos::CoordinateSequence.new(5, 2)
+    cs.set_x(0, 0)
+    cs.set_y(0, 0)
+
+    cs.set_x(1, 0)
+    cs.set_y(1, 10)
+
+    cs.set_x(2, 10)
+    cs.set_y(2, 10)
+
+    cs.set_x(3, 10)
+    cs.set_y(3, 0)
+
+    cs.set_x(4, 0)
+    cs.set_y(4, 0)
+
+    exterior_ring = Geos::create_linear_ring(cs)
+
+    geom = Geos::create_polygon(exterior_ring)
+    assert_instance_of(Geos::Polygon, geom)
+    assert_equal('Polygon', geom.geom_type)
+    assert_equal(Geos::GEOS_POLYGON, geom.type_id)
+    assert(read('POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))').eql_exact?(geom, TOLERANCE))
+  end
+
+  def test_create_polygon_with_holes
+    create_ring = lambda { |*points|
+      Geos.create_linear_ring(
+        Geos::CoordinateSequence.new(points.length, 2).tap { |cs|
+          points.each_with_index do |(x, y), i|
+            cs.set_x(i, x)
+            cs.set_y(i, y)
+          end
+        }
+      )
+    }
+
+    exterior_ring = create_ring[
+      [ 0, 0 ],
+      [ 0, 10 ],
+      [ 10, 10 ],
+      [ 10, 0 ],
+      [ 0, 0 ]
+    ]
+
+    hole_1 = create_ring[
+      [ 2, 2 ],
+      [ 2, 4 ],
+      [ 4, 4 ],
+      [ 4, 2 ],
+      [ 2, 2 ]
+    ]
+
+    hole_2 = create_ring[
+      [ 6, 6 ],
+      [ 6, 8 ],
+      [ 8, 8 ],
+      [ 8, 6 ],
+      [ 6, 6 ]
+    ]
+
+    geom = Geos::create_polygon(exterior_ring, [ hole_1, hole_2 ])
+    assert_instance_of(Geos::Polygon, geom)
+    assert_equal('Polygon', geom.geom_type)
+    assert_equal(Geos::GEOS_POLYGON, geom.type_id)
+
+    assert(!geom.empty?)
+    assert(geom.valid?)
+    assert(geom.simple?)
+    assert(!geom.ring?)
+    assert(!geom.has_z?)
+
+    assert_equal(1, geom.num_geometries)
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_multi_point)
+    def test_create_multi_point
+      @writer.rounding_precision = 0
+      assert_equal('MULTIPOINT EMPTY', write(Geos.create_multi_point))
+      assert_equal('MULTIPOINT (0 0, 10 10)', write(Geos.create_multi_point(
+        read('POINT(0 0)'),
+        read('POINT(10 10)')
+      )))
+    end
+
+    def test_create_bad_multi_point
+      assert_raise(TypeError) do
+        Geos.create_multi_point(
+          read('POINT(0 0)'),
+          read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
+        )
+      end
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_multi_line_string)
+    def test_create_multi_line_string
+      @writer.rounding_precision = 0
+      assert_equal('MULTILINESTRING EMPTY', write(Geos.create_multi_line_string))
+      assert_equal('MULTILINESTRING ((0 0, 10 10), (10 10, 20 20))', write(Geos.create_multi_line_string(
+        read('LINESTRING(0 0, 10 10)'),
+        read('LINESTRING(10 10, 20 20)')
+      )))
+    end
+
+    def test_create_bad_multi_line_string
+      assert_raise(TypeError) do
+        Geos.create_multi_point(
+          read('POINT(0 0)'),
+          read('LINESTRING(0 0, 10 0)')
+        )
+      end
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_multi_polygon)
+    def test_create_multi_polygon
+      @writer.rounding_precision = 0
+      assert_equal('MULTIPOLYGON EMPTY', write(Geos.create_multi_polygon))
+      assert_equal('MULTIPOLYGON (((0 0, 0 5, 5 5, 5 0, 0 0)), ((10 10, 10 15, 15 15, 15 10, 10 10)))', write(Geos.create_multi_polygon(
+        read('POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))'),
+        read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
+      )))
+    end
+
+    def test_create_bad_multi_polygon
+      assert_raise(TypeError) do
+        Geos.create_multi_polygon(
+          read('POINT(0 0)'),
+          read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
+        )
+      end
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_geometry_collection)
+    def test_create_geometry_collection
+      @writer.rounding_precision = 0
+      assert_equal('GEOMETRYCOLLECTION EMPTY', write(Geos.create_geometry_collection))
+      assert_equal('GEOMETRYCOLLECTION (POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0)), POLYGON ((10 10, 10 15, 15 15, 15 10, 10 10)))',
+        write(Geos.create_geometry_collection(
+          read('POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))'),
+          read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
+        ))
+      )
+    end
+
+    def test_create_bad_geometry_collection
+      assert_raise(TypeError) do
+        Geos.create_geometry_collection(
+          read('POINT(0 0)'),
+          read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))'),
+          'gibberish'
+        )
+      end
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_empty_point)
+    def test_create_empty_point
+      assert_equal('POINT EMPTY', write(Geos.create_empty_point))
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_empty_line_string)
+    def test_create_empty_line_string
+      assert_equal('LINESTRING EMPTY', write(Geos.create_empty_line_string))
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_empty_polygon)
+    def test_create_empty_polygon
+      assert_equal('POLYGON EMPTY', write(Geos.create_empty_polygon))
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_empty_multi_point)
+    def test_create_empty_multi_point
+      assert_equal('MULTIPOINT EMPTY', write(Geos.create_empty_multi_point))
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_empty_multi_line_string)
+    def test_create_empty_multi_line_string
+      assert_equal('MULTILINESTRING EMPTY', write(Geos.create_empty_multi_line_string))
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_empty_multi_polygon)
+    def test_create_empty_multi_polygon
+      assert_equal('MULTIPOLYGON EMPTY', write(Geos.create_empty_multi_polygon))
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos.method_defined?(:create_empty_geometry_collection)
+    def test_create_empty_geometry_collection
+      assert_equal('GEOMETRYCOLLECTION EMPTY', write(Geos.create_empty_geometry_collection))
+    end
+  end
+end