ffi-geos 0.0.6 → 0.1.0

data/lib/ffi-geos/version.rb

@@ -1,5 +1,5 @@
 
 module Geos
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end
 

data/lib/ffi-geos/wkb_reader.rb

@@ -18,12 +18,16 @@ module Geos
       )
     end
 
-    def read(wkb)
-      cast_geometry_ptr(FFIGeos.GEOSWKBReader_read_r(Geos.current_handle, self.ptr, wkb, wkb.bytesize))
+    def read(wkb, options = {})
+      cast_geometry_ptr(FFIGeos.GEOSWKBReader_read_r(Geos.current_handle, self.ptr, wkb, wkb.bytesize), {
+        :srid => options[:srid]
+      })
     end
 
-    def read_hex(wkb)
-      cast_geometry_ptr(FFIGeos.GEOSWKBReader_readHEX_r(Geos.current_handle, self.ptr, wkb, wkb.bytesize))
+    def read_hex(wkb, options = {})
+      cast_geometry_ptr(FFIGeos.GEOSWKBReader_readHEX_r(Geos.current_handle, self.ptr, wkb, wkb.bytesize), {
+        :srid => options[:srid]
+      })
     end
 
     def self.release(ptr) #:nodoc:

data/lib/ffi-geos/wkt_reader.rb

@@ -18,8 +18,10 @@ module Geos
       )
     end
 
-    def read(wkt)
-      cast_geometry_ptr(FFIGeos.GEOSWKTReader_read_r(Geos.current_handle, self.ptr, wkt))
+    def read(wkt, options = {})
+      cast_geometry_ptr(FFIGeos.GEOSWKTReader_read_r(Geos.current_handle, self.ptr, wkt), {
+        :srid => options[:srid]
+      })
     end
 
     def self.release(ptr) #:nodoc:

data/test/coordinate_sequence_tests.rb

@@ -2,7 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class CoordinateSequenceTests < Test::Unit::TestCase
+class CoordinateSequenceTests < MiniTest::Unit::TestCase
   include TestHelper
 
   def setup
@@ -44,29 +44,29 @@ class CoordinateSequenceTests < Test::Unit::TestCase
   end
 
   def test_check_bounds
-    assert_raise(RuntimeError) { @cs.set_x(10, 0.1) }
-    assert_raise(RuntimeError) { @cs.set_x(-1, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_x(10, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_x(-1, 0.1) }
 
-    assert_raise(RuntimeError) { @cs.set_y(10, 0.1) }
-    assert_raise(RuntimeError) { @cs.set_y(-1, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_y(10, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_y(-1, 0.1) }
 
-    assert_raise(RuntimeError) { @cs.set_z(10, 0.1) }
-    assert_raise(RuntimeError) { @cs.set_z(-1, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_z(10, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_z(-1, 0.1) }
 
-    assert_raise(RuntimeError) { @cs.set_ordinate(10, 0, 0.1) }
-    assert_raise(RuntimeError) { @cs.set_ordinate(-1, 0, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_ordinate(10, 0, 0.1) }
+    assert_raises(RuntimeError) { @cs.set_ordinate(-1, 0, 0.1) }
 
-    assert_raise(RuntimeError) { @cs.get_x(10) }
-    assert_raise(RuntimeError) { @cs.get_x(-1) }
+    assert_raises(RuntimeError) { @cs.get_x(10) }
+    assert_raises(RuntimeError) { @cs.get_x(-1) }
 
-    assert_raise(RuntimeError) { @cs.get_y(10) }
-    assert_raise(RuntimeError) { @cs.get_y(-1) }
+    assert_raises(RuntimeError) { @cs.get_y(10) }
+    assert_raises(RuntimeError) { @cs.get_y(-1) }
 
-    assert_raise(RuntimeError) { @cs.get_z(10) }
-    assert_raise(RuntimeError) { @cs.get_z(-1) }
+    assert_raises(RuntimeError) { @cs.get_z(10) }
+    assert_raises(RuntimeError) { @cs.get_z(-1) }
 
-    assert_raise(RuntimeError) { @cs.get_ordinate(10, 0) }
-    assert_raise(RuntimeError) { @cs.get_ordinate(-1, 0) }
+    assert_raises(RuntimeError) { @cs.get_ordinate(10, 0) }
+    assert_raises(RuntimeError) { @cs.get_ordinate(-1, 0) }
   end
 
   def test_clone
@@ -109,14 +109,14 @@ class CoordinateSequenceTests < Test::Unit::TestCase
     assert_equal(2, cs.dimensions)
     assert_equal(5, cs.length)
 
-    assert_raise(Geos::CoordinateSequence::ParseError) do
+    assert_raises(Geos::CoordinateSequence::ParseError) do
       cs = Geos::CoordinateSequence.new([
         [ 1, 2 ],
         [ 1, 2, 3 ]
       ])
     end
 
-    assert_raise(Geos::CoordinateSequence::ParseError) do
+    assert_raises(Geos::CoordinateSequence::ParseError) do
       cs = Geos::CoordinateSequence.new([
         [ 1, 2, 3, 4 ]
       ])
@@ -142,10 +142,10 @@ class CoordinateSequenceTests < Test::Unit::TestCase
 
   def test_empty
     cs = Geos::CoordinateSequence.new
-    assert(cs.empty?)
+    assert_geom_empty(cs)
 
     cs = Geos::CoordinateSequence.new([4,1])
-    assert(!cs.empty?)
+    refute_geom_empty(cs)
   end
 
   def test_to_empty_linear_ring
@@ -209,15 +209,15 @@ class CoordinateSequenceTests < Test::Unit::TestCase
     assert_equal('NaN', cs.z[0].to_s)
     assert_equal('NaN', cs.z[1].to_s)
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       cs.x[100]
     end
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       cs.y[100]
     end
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       cs.z[100]
     end
   end
@@ -236,15 +236,15 @@ class CoordinateSequenceTests < Test::Unit::TestCase
     assert_equal(2, cs.get_y(0))
     assert_equal(11, cs.get_y(1))
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       cs.x[100] = 10
     end
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       cs.y[100] = 10
     end
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       cs.z[100] = 10
     end
   end
@@ -271,4 +271,58 @@ class CoordinateSequenceTests < Test::Unit::TestCase
     assert_kind_of(Enumerable, cs.to_enum)
     assert_equal(cs, cs.each {})
   end
+
+  def test_array_like_access
+    cs = Geos::CoordinateSequence.new([
+      [ 0, 1 ],
+      [ 2, 3 ]
+    ])
+
+    assert_equal(0, cs[0][0])
+    assert_equal(1, cs[0][1])
+    assert_equal(2, cs[1][0])
+    assert_equal(3, cs[1][1])
+
+    cs = Geos::CoordinateSequence.new([
+      [ 4, 5, 6 ]
+    ])
+
+    assert_equal(4, cs[0][0])
+    assert_equal(5, cs[0][1])
+    assert_equal(6, cs[0][2])
+  end
+
+  def test_slice
+    cs = Geos::CoordinateSequence.new([
+      [ 0, 1 ],
+      [ 2, 3 ],
+      [ 4, 5 ]
+    ])
+
+    assert_equal([[0, 1], [2, 3]], cs.slice(0..1))
+    assert_equal([4, 5], cs.slice(-1))
+    assert_equal([[0, 1], [2, 3]], cs.slice(0, 2))
+  end
+
+  def test_proxy_clone
+    cs = Geos::CoordinateSequence.new([ 10, 20 ])
+    cs2 = cs.clone
+
+    cs.x[0] = 100
+
+    assert_equal(100, cs.x[0])
+    assert_equal(10, cs2.x[0])
+
+    refute_equal(cs.x, cs2.x)
+    refute_equal(cs.y, cs2.y)
+  end
+
+  def test_has_z
+    assert_geom_has_z(Geos::CoordinateSequence.new([ 0, 1, 2 ]))
+    refute_geom_has_z(Geos::CoordinateSequence.new([ 0, 1 ]))
+    refute_geom_has_z(Geos::CoordinateSequence.new(1, 2))
+    assert_geom_has_z(Geos::CoordinateSequence.new(1, 3))
+    assert_geom_has_z(read('POINT (0 0 0)').coord_seq)
+    refute_geom_has_z(read('POINT (0 0)').coord_seq)
+  end
 end

data/test/geometry_collection_tests.rb

@@ -0,0 +1,79 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeometryCollectionTests < MiniTest::Unit::TestCase
+  include TestHelper
+
+  if ENV['FORCE_TESTS'] || Geos::GeometryCollection.method_defined?(:[])
+    def test_geometry_collection_enumerator
+      geom = read('GEOMETRYCOLLECTION(POINT(0 0))')
+      assert_kind_of(Enumerable, geom.each)
+      assert_kind_of(Enumerable, geom.to_enum)
+      assert_equal(geom, geom.each {})
+    end
+
+    def test_geometry_collection_array
+      writer.trim = true
+      geom = read('GEOMETRYCOLLECTION(
+        LINESTRING(0 0, 1 1, 2 2, 3 3),
+        POINT(10 20),
+        POLYGON((0 0, 0 5, 5 5, 5 0, 0 0)),
+        POINT(10 20)
+      )')
+
+      assert_equal('LINESTRING (0 0, 1 1, 2 2, 3 3)', write(geom[0]))
+      assert_equal('POINT (10 20)', write(geom[-1]))
+
+      assert_equal([
+        'LINESTRING (0 0, 1 1, 2 2, 3 3)',
+        'POINT (10 20)'
+      ], geom[0, 2].collect { |g| write(g) })
+
+      assert_equal(nil, geom[0, -1])
+      assert_equal([], geom[-1, 0])
+      assert_equal([
+        'POINT (10 20)',
+        'POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))'
+      ], geom[1..2].collect { |g| write(g) })
+    end
+  end
+
+  if ENV['FORCE_TESTS'] || Geos::GeometryCollection.method_defined?(:detect)
+    def test_geometry_collection_enumerable
+      writer.trim = true
+      geom = read('GEOMETRYCOLLECTION(
+        LINESTRING(0 0, 1 1, 2 2, 3 3, 10 0, 2 2),
+        POINT(10 20),
+        POLYGON((0 0, 0 5, 5 5, 5 0, 0 0)),
+        POINT(10 20)
+      )')
+
+      assert_equal(2, geom.select { |point| point == read('POINT(10 20)') }.length)
+    end
+  end
+
+  def test_default_srid
+    geom = read('GEOMETRYCOLLECTION (POINT(0 0))')
+    assert_equal(0, geom.srid)
+  end
+
+  def test_setting_srid_manually
+    geom = read('GEOMETRYCOLLECTION (POINT(0 0))')
+    geom.srid = 4326
+    assert_equal(4326, geom.srid)
+  end
+
+  def test_dimensions
+    geom = read('GEOMETRYCOLLECTION (POINT(0 0))')
+    assert_equal(0, geom.dimensions)
+
+    geom = read('GEOMETRYCOLLECTION (LINESTRING(1 2, 3 4))')
+    assert_equal(1, geom.dimensions)
+  end
+
+  def test_num_geometries
+    geom = read('GEOMETRYCOLLECTION (POINT(1 2), LINESTRING(1 2, 3 4))')
+    assert_equal(2, geom.num_geometries)
+  end
+end

data/test/geometry_tests.rb

@@ -2,7 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class GeometryTests < Test::Unit::TestCase
+class GeometryTests < MiniTest::Unit::TestCase
   include TestHelper
 
   def comparison_tester(method_with_args, geom_a, geom_b, expected)
@@ -13,14 +13,14 @@ class GeometryTests < Test::Unit::TestCase
     geom_1 = read(geom_a)
     geom_b = read(geom_b)
     result = geom_1.send(method, geom_b, *args)
-    assert(read(expected).eql_exact?(result, TOLERANCE))
+    assert_geom_eql_exact(read(expected), result)
   end
 
   def self_tester(method_with_args, g, expected)
     method_with_args = Array(method_with_args)
     geom = read(g)
     result = geom.send(*method_with_args)
-    assert(read(expected).eql_exact?(result, TOLERANCE))
+    assert_geom_eql_exact(read(expected), result)
   end
 
   def test_intersection
@@ -38,7 +38,7 @@ class GeometryTests < Test::Unit::TestCase
       assert_equal(expected, write(read(geom).buffer(width, params)))
     }
 
-    @writer.rounding_precision = 0
+    writer.rounding_precision = 0
 
     tester['POLYGON EMPTY', 'POINT(0 0)', 0]
 
@@ -123,72 +123,15 @@ class GeometryTests < Test::Unit::TestCase
     ]
   end
 
-  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:offset_curve)
-    def test_offset_curve
-      tester = lambda { |expected, g, width, style|
-        geom = read(g)
-        buffered = geom.offset_curve(width, style)
-
-        assert_equal(expected, write(buffered))
-      }
-
-      @writer.rounding_precision = 0
-
-      # straight left
-      tester[
-        'LINESTRING (0 2, 10 2)',
-        'LINESTRING (0 0, 10 0)',
-        2, {
-          :quad_segs => 0,
-          :join => :round,
-          :mitre_limit => 2
-        }
-      ]
-
-      # straight right
-      tester[
-        'LINESTRING (10 -2, 0 -2)',
-        'LINESTRING (0 0, 10 0)',
-        -2, {
-          :quad_segs => 0,
-          :join => :round,
-          :mitre_limit => 2
-        }
-      ]
-
-      # outside curve
-      tester[
-        'LINESTRING (12 10, 12 0, 10 -2, 0 -2)',
-        'LINESTRING (0 0, 10 0, 10 10)',
-        -2, {
-          :quad_segs => 1,
-          :join => :round,
-          :mitre_limit => 2
-        }
-      ]
-
-      # inside curve
-      tester[
-        'LINESTRING (0 2, 8 2, 8 10)',
-        'LINESTRING (0 0, 10 0, 10 10)',
-        2, {
-          :quad_segs => 1,
-          :join => :round,
-          :mitre_limit => 2
-        }
-      ]
-    end
-  end
-
   def test_convex_hull
     geom = read('POINT(0 0)')
-    assert(read('POINT(0 0)').eql_exact?(geom.convex_hull, TOLERANCE))
+    assert_geom_eql_exact(read('POINT(0 0)'), geom.convex_hull)
 
     geom = read('LINESTRING(0 0, 10 10)')
-    assert(read('LINESTRING(0 0, 10 10)').eql_exact?(geom.convex_hull, TOLERANCE))
+    assert_geom_eql_exact(read('LINESTRING(0 0, 10 10)'), geom.convex_hull)
 
     geom = read('POLYGON((0 0, 0 10, 5 5, 10 10, 10 0, 0 0))')
-    assert(read('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))').eql_exact?(geom.convex_hull, TOLERANCE))
+    assert_geom_eql_exact(read('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))'), geom.convex_hull)
   end
 
   def test_difference
@@ -335,6 +278,78 @@ class GeometryTests < Test::Unit::TestCase
     )
   end
 
+  def test_symmetric_difference
+    comparison_tester(
+      :symmetric_difference,
+      'POINT(0 0)',
+      'POINT(0 0)',
+      'GEOMETRYCOLLECTION EMPTY'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'POINT(0 0)',
+      'POINT(1 0)',
+      'MULTIPOINT (0 0, 1 0)'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'LINESTRING(0 0, 10 0)',
+      'POINT(5 0)',
+      'LINESTRING (0 0, 10 0)'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'POINT(5 0)',
+      'LINESTRING(0 0, 10 0)',
+      'LINESTRING (0 0, 10 0)'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'POINT(5 0)',
+      'LINESTRING(0 1, 10 1)',
+      'GEOMETRYCOLLECTION (POINT (5 0), LINESTRING (0 1, 10 1))'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'LINESTRING(0 0, 10 0)',
+      'LINESTRING(5 -10, 5 10)',
+      'MULTILINESTRING ((0 0, 5 0), (5 0, 10 0), (5 -10, 5 0), (5 0, 5 10))'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'LINESTRING(0 0, 10 0)',
+      'LINESTRING(5 0, 20 0)',
+      'MULTILINESTRING ((0 0, 5 0), (10 0, 20 0))'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))',
+      'LINESTRING(5 -10, 5 10)',
+      'GEOMETRYCOLLECTION (LINESTRING (5 -10, 5 0), POLYGON ((5 0, 0 0, 0 10, 5 10, 10 10, 10 0, 5 0)))'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))',
+      'LINESTRING(10 0, 20 0)',
+      'GEOMETRYCOLLECTION (LINESTRING (10 0, 20 0), POLYGON ((10 0, 0 0, 0 10, 10 10, 10 0)))'
+    )
+
+    comparison_tester(
+      :symmetric_difference,
+      'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))',
+      'POLYGON((5 -5, 5 5, 15 5, 15 -5, 5 -5))',
+      'MULTIPOLYGON (((5 0, 0 0, 0 10, 10 10, 10 5, 5 5, 5 0)), ((5 0, 10 0, 10 5, 15 5, 15 -5, 5 -5, 5 0)))'
+    )
+  end
+
   def test_boundary
     self_tester(
       :boundary,
@@ -502,6 +517,26 @@ class GeometryTests < Test::Unit::TestCase
     )
   end
 
+  def test_representative_point
+    self_tester(
+      :representative_point,
+      'POINT(0 0)',
+      'POINT(0 0)'
+    )
+
+    self_tester(
+      :representative_point,
+      'LINESTRING(0 0, 5 5, 10 10)',
+      'POINT (5 5)'
+    )
+
+    self_tester(
+      :representative_point,
+      'POLYGON((0 0, 0 10, 5 5, 10 10, 10 0, 0 0))',
+      'POINT (2.5 5)'
+    )
+  end
+
   def test_centroid
     self_tester(
       :centroid,
@@ -589,7 +624,7 @@ class GeometryTests < Test::Unit::TestCase
       ret = geom_a.relate_boundary_node_rule(geom_b, :endpoint)
       assert_equal('FF10FFFF2', ret)
 
-      assert_raise(TypeError) do
+      assert_raises(TypeError) do
         geom_a.relate_boundary_node_rule(geom_b, :gibberish)
       end
     end
@@ -775,20 +810,20 @@ class GeometryTests < Test::Unit::TestCase
   end
 
   def test_empty
-    assert(!read('POINT(0 0)').empty?)
-    assert(read('POINT EMPTY').empty?)
-    assert(!read('LINESTRING(0 0, 10 0)').empty?)
-    assert(read('LINESTRING EMPTY').empty?)
-    assert(!read('POLYGON((0 0, 10 0, 10 10, 0 0))').empty?)
-    assert(read('POLYGON EMPTY').empty?)
-    assert(!read('GEOMETRYCOLLECTION(POINT(0 0))').empty?)
-    assert(read('GEOMETRYCOLLECTION EMPTY').empty?)
+    refute_geom_empty(read('POINT(0 0)'))
+    assert_geom_empty(read('POINT EMPTY'))
+    refute_geom_empty(read('LINESTRING(0 0, 10 0)'))
+    assert_geom_empty(read('LINESTRING EMPTY'))
+    refute_geom_empty(read('POLYGON((0 0, 10 0, 10 10, 0 0))'))
+    assert_geom_empty(read('POLYGON EMPTY'))
+    refute_geom_empty(read('GEOMETRYCOLLECTION(POINT(0 0))'))
+    assert_geom_empty(read('GEOMETRYCOLLECTION EMPTY'))
   end
 
   def test_valid
-    assert(read('POINT(0 0)').valid?)
-    assert(!read('POINT(0 NaN)').valid?)
-    assert(!read('POINT(0 nan)').valid?)
+    assert_geom_valid(read('POINT(0 0)'))
+    refute_geom_valid(read('POINT(0 NaN)'))
+    refute_geom_valid(read('POINT(0 nan)'))
   end
 
   if ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:valid_reason)
@@ -823,28 +858,20 @@ class GeometryTests < Test::Unit::TestCase
   end
 
   def test_simple
-    assert(read('POINT(0 0)').simple?)
-    assert(read('LINESTRING(0 0, 10 0)').simple?)
-    assert(!read('LINESTRING(0 0, 10 0, 5 5, 5 -5)').simple?)
+    assert_geom_simple(read('POINT(0 0)'))
+    assert_geom_simple(read('LINESTRING(0 0, 10 0)'))
+    refute_geom_simple(read('LINESTRING(0 0, 10 0, 5 5, 5 -5)'))
   end
 
   def test_ring
-    assert(!read('POINT(0 0)').ring?)
-    assert(!read('LINESTRING(0 0, 10 0, 5 5, 5 -5)').ring?)
-    assert(read('LINESTRING(0 0, 10 0, 5 5, 0 0)').ring?)
+    refute_geom_ring(read('POINT(0 0)'))
+    refute_geom_ring(read('LINESTRING(0 0, 10 0, 5 5, 5 -5)'))
+    assert_geom_ring(read('LINESTRING(0 0, 10 0, 5 5, 0 0)'))
   end
 
   def test_has_z
-    assert(!read('POINT(0 0)').has_z?)
-    assert(read('POINT(0 0 0)').has_z?)
-  end
-
-  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:closed?)
-    def test_closed
-      assert(read('LINESTRING(0 0, 1 1, 2 2, 0 0)').closed?)
-      assert(!read('LINESTRING(0 0, 1 1, 2 2)').closed?)
-      assert(read('LINEARRING(0 0, 1 1, 2 2, 0 0)').closed?)
-    end
+    refute_geom_has_z(read('POINT(0 0)'))
+    assert_geom_has_z(read('POINT(0 0 0)'))
   end
 
   def test_num_geometries
@@ -887,7 +914,7 @@ class GeometryTests < Test::Unit::TestCase
         if expected.nil?
           assert_nil(result)
         else
-          assert(result.eql_exact?(read(expected), TOLERANCE))
+          assert_geom_eql_exact(result, read(expected))
         end
       }
 
@@ -914,7 +941,7 @@ class GeometryTests < Test::Unit::TestCase
       (13 11, 13 12, 13.5 12, 13.5 11, 13 11))'
     ]
 
-    assert_raise(NoMethodError) do
+    assert_raises(NoMethodError) do
       tester[0, 'POINT (0 0)']
     end
   end
@@ -927,7 +954,7 @@ class GeometryTests < Test::Unit::TestCase
       if expected.nil?
         assert_nil(result)
       else
-        assert(result.eql_exact?(read(expected), TOLERANCE))
+        assert_geom_eql_exact(result, read(expected))
       end
     }
 
@@ -960,7 +987,7 @@ class GeometryTests < Test::Unit::TestCase
       1
     ]
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       tester[
         nil,
         'POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))',
@@ -968,7 +995,7 @@ class GeometryTests < Test::Unit::TestCase
       ]
     end
 
-    assert_raise(NoMethodError) do
+    assert_raises(NoMethodError) do
       tester[
         nil,
         'POINT (0 0)',
@@ -985,7 +1012,7 @@ class GeometryTests < Test::Unit::TestCase
       if expected.nil?
         assert_nil(result)
       else
-        assert(result.eql_exact?(read(expected), TOLERANCE))
+        assert_geom_eql_exact(result, read(expected))
       end
     }
 
@@ -997,7 +1024,7 @@ class GeometryTests < Test::Unit::TestCase
       )'
     ]
 
-    assert_raise(NoMethodError) do
+    assert_raises(NoMethodError) do
       tester[
         nil,
         'POINT (0 0)'
@@ -1089,31 +1116,6 @@ class GeometryTests < Test::Unit::TestCase
     tester[[[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]], 'LINEARRING(0 0, 0 5, 5 5, 5 0, 0 0)']
   end
 
-  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:num_points)
-    def test_num_points
-      assert_equal(4, read('LINESTRING (0 0, 1 0, 1 1, 0 1)').num_points)
-
-      assert_raise(NoMethodError) do
-        read('POINT (0 0)').num_points
-      end
-    end
-  end
-
-  if ENV['FORCE_TESTS'] || Geos::Point.method_defined?(:get_x)
-    def test_get_x_and_get_y
-      geom = read('POINT (1 2)')
-      assert_equal(1, geom.get_x)
-      assert_equal(2, geom.get_y)
-
-      assert_equal(1, geom.x)
-      assert_equal(2, geom.y)
-
-      assert_raise(NoMethodError) do
-        read('LINESTRING (0 0, 1 1)').get_x
-      end
-    end
-  end
-
   def test_dimensions
     tester = lambda { |expected, g|
       geom = read(g)
@@ -1161,7 +1163,7 @@ class GeometryTests < Test::Unit::TestCase
       geom_b = read('POINT(3 4)')
 
       # The method only accept lineal geometries
-      assert_raise(RuntimeError) do
+      assert_raises(RuntimeError) do
         geom_a.project(geom_b)
       end
 
@@ -1207,42 +1209,12 @@ class GeometryTests < Test::Unit::TestCase
       tester['POINT (10 0)', 'LINESTRING(0 0, 10 0)', 20, false]
       tester['POINT (10 0)', 'LINESTRING(0 0, 10 0)', 2, true]
 
-      assert_raise(RuntimeError) do
+      assert_raises(RuntimeError) do
         read('POINT(1 2)').interpolate(0)
       end
     end
   end
 
-  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:point_n)
-    def test_point_n
-      writer.rounding_precision = 0
-
-      tester = lambda { |expected, geom, n|
-        assert_equal(expected, write(geom.point_n(n)))
-      }
-
-      geom = read('LINESTRING (10 10, 10 14, 14 14, 14 10)')
-      tester['POINT (10 10)', geom, 0]
-      tester['POINT (10 14)', geom, 1]
-      tester['POINT (14 14)', geom, 2]
-      tester['POINT (14 10)', geom, 3]
-
-      assert_raise(RuntimeError) do
-        tester['POINT (0 0)', geom, 4]
-      end
-
-      geom = read('LINEARRING (11 11, 11 12, 12 11, 11 11)')
-      tester['POINT (11 11)', geom, 0]
-      tester['POINT (11 12)', geom, 1]
-      tester['POINT (12 11)', geom, 2]
-      tester['POINT (11 11)', geom, 3]
-
-      assert_raise(NoMethodError) do
-        tester[nil, read('POINT (0 0)'), 0]
-      end
-    end
-  end
-
   if ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:start_point)
     def test_start_and_end_points
       writer.rounding_precision = 0
@@ -1329,7 +1301,7 @@ class GeometryTests < Test::Unit::TestCase
       tester = lambda { |expected, g1, g2, tolerance|
         geom_a = read(g1)
         geom_b = read(g2)
-        assert(read(expected).eql_exact?(geom_a.snap(geom_b, tolerance), TOLERANCE))
+        assert_geom_eql_exact(read(expected), geom_a.snap(geom_b, tolerance))
       }
 
       writer.trim = true
@@ -1404,10 +1376,10 @@ class GeometryTests < Test::Unit::TestCase
 
       polygonized = geom_a.polygonize_full
 
-      assert(polygonized[:rings].is_a?(Array))
-      assert(polygonized[:cuts].is_a?(Array))
-      assert(polygonized[:dangles].is_a?(Array))
-      assert(polygonized[:invalid_rings].is_a?(Array))
+      assert_kind_of(Array, polygonized[:rings])
+      assert_kind_of(Array, polygonized[:cuts])
+      assert_kind_of(Array, polygonized[:dangles])
+      assert_kind_of(Array, polygonized[:invalid_rings])
 
       assert_equal(2, polygonized[:rings].length)
       assert_equal(0, polygonized[:cuts].length)
@@ -1452,7 +1424,7 @@ class GeometryTests < Test::Unit::TestCase
     end
 
     def test_polygonize_with_bad_arguments
-      assert_raise(ArgumentError) do
+      assert_raises(ArgumentError) do
         geom = read('POINT(0 0)')
 
         geom.polygonize(geom, 'gibberish')
@@ -1480,83 +1452,11 @@ class GeometryTests < Test::Unit::TestCase
     end
   end
 
-  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:select)
-    def test_line_string_enumerable
-      @writer.trim = true
-      geom = read('LINESTRING(0 0, 1 1, 2 2, 3 3, 10 0, 2 2)')
-
-      assert_equal(2, geom.select { |point| point == read('POINT(2 2)') }.length)
-    end
-  end
-
-  if ENV['FORCE_TESTS'] || Geos::GeometryCollection.method_defined?(:detect)
-    def test_geometry_collection_enumerable
-      @writer.trim = true
-      geom = read('GEOMETRYCOLLECTION(
-        LINESTRING(0 0, 1 1, 2 2, 3 3, 10 0, 2 2),
-        POINT(10 20),
-        POLYGON((0 0, 0 5, 5 5, 5 0, 0 0)),
-        POINT(10 20)
-      )')
-
-      assert_equal(2, geom.select { |point| point == read('POINT(10 20)') }.length)
-    end
-  end
-
-  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:[])
-    def test_line_string_array
-      @writer.trim = true
-      geom = read('LINESTRING(0 0, 1 1, 2 2, 3 3, 4 4)')
-
-      assert_equal('POINT (0 0)', write(geom[0]))
-      assert_equal('POINT (4 4)', write(geom[-1]))
-
-      assert_equal([
-        'POINT (0 0)',
-        'POINT (1 1)'
-      ], geom[0, 2].collect { |g| write(g) })
-
-      assert_equal(nil, geom[0, -1])
-      assert_equal([], geom[-1, 0])
-      assert_equal([
-        'POINT (1 1)',
-        'POINT (2 2)'
-      ], geom[1..2].collect { |g| write(g) })
-    end
-  end
-
-  if ENV['FORCE_TESTS'] || Geos::GeometryCollection.method_defined?(:[])
-    def test_geometry_collection_array
-      @writer.trim = true
-      geom = read('GEOMETRYCOLLECTION(
-        LINESTRING(0 0, 1 1, 2 2, 3 3),
-        POINT(10 20),
-        POLYGON((0 0, 0 5, 5 5, 5 0, 0 0)),
-        POINT(10 20)
-      )')
-
-      assert_equal('LINESTRING (0 0, 1 1, 2 2, 3 3)', write(geom[0]))
-      assert_equal('POINT (10 20)', write(geom[-1]))
-
-      assert_equal([
-        'LINESTRING (0 0, 1 1, 2 2, 3 3)',
-        'POINT (10 20)'
-      ], geom[0, 2].collect { |g| write(g) })
-
-      assert_equal(nil, geom[0, -1])
-      assert_equal([], geom[-1, 0])
-      assert_equal([
-        'POINT (10 20)',
-        'POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))'
-      ], geom[1..2].collect { |g| write(g) })
-    end
-  end
-
   def test_clone
     geom_a = read('POINT(0 0)')
     geom_b = geom_a.clone
 
-    assert(geom_a.eql?(geom_b))
+    assert_equal(geom_a, geom_b)
   end
 
   def test_clone_srid
@@ -1565,7 +1465,7 @@ class GeometryTests < Test::Unit::TestCase
     geom_a.srid = srid
     geom_b = geom_a.clone
 
-    assert(geom_a.eql?(geom_b))
+    assert_equal(geom_a, geom_b)
     assert_equal(srid, geom_b.srid)
   end
 
@@ -1573,7 +1473,7 @@ class GeometryTests < Test::Unit::TestCase
     geom_a = read('POINT(0 0)')
     geom_b = geom_a.dup
 
-    assert(geom_a.eql?(geom_b))
+    assert_equal(geom_a, geom_b)
   end
 
   def test_dup_srid
@@ -1581,17 +1481,10 @@ class GeometryTests < Test::Unit::TestCase
     geom_a = read('POINT(0 0)')
     geom_a.srid = srid
     geom_b = geom_a.dup
-    assert(geom_a.eql?(geom_b))
+    assert_equal(geom_a, geom_b)
     assert_equal(srid, geom_b.srid)
   end
 
-  def test_geometry_collection_enumerator
-    geom = read('GEOMETRYCOLLECTION(POINT(0 0))')
-    assert_kind_of(Enumerable, geom.each)
-    assert_kind_of(Enumerable, geom.to_enum)
-    assert_equal(geom, geom.each {})
-  end
-
   def test_line_string_enumerator
     geom = read('LINESTRING(0 0, 10 10))')
     assert_kind_of(Enumerable, geom.each)
@@ -1600,20 +1493,113 @@ class GeometryTests < Test::Unit::TestCase
   end
 
   def test_normalize
+    writer.trim = true
+
     geom = read('POLYGON((0 0, 5 0, 5 5, 0 5, 0 0))')
     geom.normalize
-    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom, :trim => true))
+    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom))
 
     geom = read('POLYGON((0 0, 5 0, 5 5, 0 5, 0 0))').normalize
-    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom, :trim => true))
+    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom))
   end
 
   def test_normalize_bang
+    writer.trim = true
+
     geom = read('POLYGON((0 0, 5 0, 5 5, 0 5, 0 0))')
     geom.normalize!
-    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom, :trim => true))
+    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom))
 
     geom = read('POLYGON((0 0, 5 0, 5 5, 0 5, 0 0))').normalize!
-    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom, :trim => true))
+    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(geom))
+  end
+
+  def test_eql
+    geom_a = read('POINT(1.0 1.0)')
+    geom_b = read('POINT(2.0 2.0)')
+
+    %w{ eql? equals? == }.each do |method|
+      refute(geom_a.send(method, geom_b), "Expected geoms to not be equal using #{method}")
+    end
+  end
+
+  def test_eql_exact
+    geom_a = read('POINT(1.0 1.0)')
+    geom_b = read('POINT(2.0 2.0)')
+
+    %w{ eql_exact? equals_exact? exactly_equals? }.each do |method|
+      refute(geom_a.send(method, geom_b, 0.001), "Expected geoms to not be equal using #{method}")
+    end
+  end
+
+  def test_eql_almost_default
+    geom = read('POINT (1 1)')
+    geom_a = read('POINT (1.0000001 1.0000001)')
+    geom_b = read('POINT (1.000001 1.000001)')
+
+    %w{ eql_almost? equals_almost? almost_equals? }.each do |method|
+      assert(geom.send(method, geom_a), "Expected geoms to be equal using #{method}")
+      refute(geom.send(method, geom_b), "Expected geoms to not be equal using #{method}")
+    end
+  end
+
+  def test_eql_almost
+    geom_a = read('POINT(1.0 1.0)')
+    geom_b = read('POINT(1.1 1.1)')
+
+    refute_equal(geom_a, geom_b)
+
+    %w{ eql_almost? equals_almost? almost_equals? }.each do |method|
+      assert(geom_a.send(method, geom_b, 0), "Expected geoms to be equal using #{method}")
+      refute(geom_a.send(method, geom_b, 1), "Expected geoms to not be equal using #{method}")
+    end
+  end
+
+  def test_srid_copy_policy
+    geom = read('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))')
+    geom.srid = 4326
+
+    Geos.srid_copy_policy = :zero
+    cloned = geom.clone
+    assert_equal(4326, cloned.srid)
+
+    Geos.srid_copy_policy = :lenient
+    cloned = geom.clone
+    assert_equal(4326, cloned.srid)
+
+    Geos.srid_copy_policy = :strict
+    cloned = geom.clone
+    assert_equal(4326, cloned.srid)
+
+    Geos.srid_copy_policy = :zero
+    geom_b = geom.convex_hull
+    assert_equal(0, geom_b.srid)
+
+    Geos.srid_copy_policy = :lenient
+    geom_b = geom.convex_hull
+    assert_equal(4326, geom_b.srid)
+
+    Geos.srid_copy_policy = :strict
+    geom_b = geom.convex_hull
+    assert_equal(4326, geom_b.srid)
+
+    geom_b = read('POLYGON ((3 3, 3 8, 8 8, 8 3, 3 3))')
+    geom_b.srid = 3875
+
+    Geos.srid_copy_policy = :zero
+    geom_c = geom.intersection(geom_b)
+    assert_equal(0, geom_c.srid)
+
+    Geos.srid_copy_policy = :lenient
+    geom_c = geom.intersection(geom_b)
+    assert_equal(4326, geom_c.srid)
+
+    assert_raises(Geos::MixedSRIDsError) do
+      Geos.srid_copy_policy = :strict
+      geom_c = geom.intersection(geom_b)
+      assert_equal(231231, geom_c.srid)
+    end
+  ensure
+    Geos.srid_copy_policy = :default
   end
 end