ffi-geos 0.1.1 → 0.1.2

data/test/utils_tests.rb

@@ -6,31 +6,29 @@ require 'test_helper'
 class UtilsTests < MiniTest::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
+  def test_orientation_index
+    skip unless ENV['FORCE_TESTS'] || (defined?(Geos::Utils) && Geos::Utils.respond_to?(: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
 
-    if Geos::Utils.respond_to?(:relate_match)
-      def test_relate_match
-        assert(Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFF2'), "'0FFFFFFF2' and '0FFFFFFF2' patterns match")
-        assert(Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFF*'), "'0FFFFFFF2' and '0FFFFFFF*' patterns match")
-        assert(Geos::Utils.relate_match('0FFFFFFF2', 'TFFFFFFF2'), "'0FFFFFFF2' and 'TFFFFFFF2' patterns match")
-        assert(!Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFFF'), "'0FFFFFFF2' and '0FFFFFFFF' patterns match")
-      end
-    end
+  def test_relate_match
+    skip unless ENV['FORCE_TESTS'] || (defined?(Geos::Utils) && Geos::Utils.respond_to?(:relate_match))
+
+    assert(Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFF2'), "'0FFFFFFF2' and '0FFFFFFF2' patterns match")
+    assert(Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFF*'), "'0FFFFFFF2' and '0FFFFFFF*' patterns match")
+    assert(Geos::Utils.relate_match('0FFFFFFF2', 'TFFFFFFF2'), "'0FFFFFFF2' and 'TFFFFFFF2' patterns match")
+    assert(!Geos::Utils.relate_match('0FFFFFFF2', '0FFFFFFFF'), "'0FFFFFFF2' and '0FFFFFFFF' patterns match")
   end
 
   def create_method_tester(expected, method, cs, type_id, klass)
@@ -264,147 +262,159 @@ class UtilsTests < MiniTest::Unit::TestCase
     assert_equal(1, geom.num_geometries)
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(: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(
+  def test_create_multi_point
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(: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
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_multi_point)
+
+    assert_raises(TypeError) do
+      Geos.create_multi_point(
         read('POINT(0 0)'),
-        read('POINT(10 10)')
-      )))
+        read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
+      )
     end
+  end
 
-    def test_create_bad_multi_point
-      assert_raises(TypeError) do
-        Geos.create_multi_point(
-          read('POINT(0 0)'),
-          read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
-        )
-      end
-    end
+  def test_create_multi_line_string
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(: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
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(: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)')
-      )))
+  def test_create_bad_multi_line_string
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_multi_line_string)
+
+    assert_raises(TypeError) do
+      Geos.create_multi_point(
+        read('POINT(0 0)'),
+        read('LINESTRING(0 0, 10 0)')
+      )
     end
+  end
+
+  def test_create_multi_polygon
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(: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
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_multi_polygon)
 
-    def test_create_bad_multi_line_string
-      assert_raises(TypeError) do
-        Geos.create_multi_point(
-          read('POINT(0 0)'),
-          read('LINESTRING(0 0, 10 0)')
-        )
-      end
+    assert_raises(TypeError) do
+      Geos.create_multi_polygon(
+        read('POINT(0 0)'),
+        read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
+      )
     end
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(: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(
+  def test_create_geometry_collection
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(: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
+      ))
+    )
+  end
 
-    def test_create_bad_multi_polygon
-      assert_raises(TypeError) do
-        Geos.create_multi_polygon(
-          read('POINT(0 0)'),
-          read('POLYGON((10 10, 10 15, 15 15, 15 10, 10 10))')
-        )
-      end
-    end
+  def test_create_geometry_collection_with_constants_and_symbols
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_geometry_collection)
+
+    assert_kind_of(Geos::MultiLineString, Geos.create_collection(Geos::GeomTypes::GEOS_MULTILINESTRING))
+    assert_kind_of(Geos::MultiLineString, Geos.create_collection(:multi_line_string))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(: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
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_geometry_collection)
 
-    def test_create_geometry_collection_with_constants_and_symbols
-      assert_kind_of(Geos::MultiLineString, Geos.create_collection(Geos::GeomTypes::GEOS_MULTILINESTRING))
-      assert_kind_of(Geos::MultiLineString, Geos.create_collection(:multi_line_string))
+    assert_raises(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
 
-    def test_create_bad_geometry_collection
-      assert_raises(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
+  def test_create_geometry_collection_with_options
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_geometry_collection)
 
-    def test_create_geometry_collection_with_options
-      geom = Geos.create_collection(:multi_line_string, :srid => 4326)
+    geom = Geos.create_collection(:multi_line_string, :srid => 4326)
 
-      assert_kind_of(Geos::MultiLineString, geom)
-      assert_equal(4326, geom.srid)
-    end
+    assert_kind_of(Geos::MultiLineString, geom)
+    assert_equal(4326, geom.srid)
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_point)
-    def test_create_empty_point
-      assert_equal('POINT EMPTY', write(Geos.create_empty_point))
-    end
+  def test_create_empty_point
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_point)
+
+    assert_equal('POINT EMPTY', write(Geos.create_empty_point))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_line_string)
-    def test_create_empty_line_string
-      assert_equal('LINESTRING EMPTY', write(Geos.create_empty_line_string))
-    end
+  def test_create_empty_line_string
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_line_string)
+
+    assert_equal('LINESTRING EMPTY', write(Geos.create_empty_line_string))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_polygon)
-    def test_create_empty_polygon
-      assert_equal('POLYGON EMPTY', write(Geos.create_empty_polygon))
-    end
+  def test_create_empty_polygon
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_polygon)
+
+    assert_equal('POLYGON EMPTY', write(Geos.create_empty_polygon))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_multi_point)
-    def test_create_empty_multi_point
-      assert_equal('MULTIPOINT EMPTY', write(Geos.create_empty_multi_point))
-    end
+  def test_create_empty_multi_point
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_multi_point)
+
+    assert_equal('MULTIPOINT EMPTY', write(Geos.create_empty_multi_point))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_multi_line_string)
-    def test_create_empty_multi_line_string
-      assert_equal('MULTILINESTRING EMPTY', write(Geos.create_empty_multi_line_string))
-    end
+  def test_create_empty_multi_line_string
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_multi_line_string)
+
+    assert_equal('MULTILINESTRING EMPTY', write(Geos.create_empty_multi_line_string))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_multi_polygon)
-    def test_create_empty_multi_polygon
-      assert_equal('MULTIPOLYGON EMPTY', write(Geos.create_empty_multi_polygon))
-    end
+  def test_create_empty_multi_polygon
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_multi_polygon)
+
+    assert_equal('MULTIPOLYGON EMPTY', write(Geos.create_empty_multi_polygon))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_geometry_collection)
-    def test_create_empty_geometry_collection
-      assert_equal('GEOMETRYCOLLECTION EMPTY', write(Geos.create_empty_geometry_collection))
-    end
+  def test_create_empty_geometry_collection
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_geometry_collection)
+
+    assert_equal('GEOMETRYCOLLECTION EMPTY', write(Geos.create_empty_geometry_collection))
   end
 
-  if ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_linear_ring)
-    def test_create_empty_linear_ring
-      assert_equal('LINEARRING EMPTY', write(Geos.create_empty_linear_ring))
-    end
+  def test_create_empty_linear_ring
+    skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_empty_linear_ring)
+
+    assert_equal('LINEARRING EMPTY', write(Geos.create_empty_linear_ring))
   end
 
   def test_create_geometry_segfault

data/test/wkb_writer_tests.rb

@@ -426,18 +426,17 @@ class WkbWriterTests < MiniTest::Unit::TestCase
     end
   end
 
-  if ENV['FORCE_TESTS'] || defined?(Geos::FFIGeos)
-    def test_write_with_options
-      geom = read('POINT(1 2 3)')
-      geom.srid = 4326
+  def test_write_with_options
+    skip unless ENV['FORCE_TESTS'] || defined?(Geos::FFIGeos)
 
+    geom = read('POINT(1 2 3)')
+    geom.srid = 4326
 
-      assert_equal('0101000020E6100000000000000000F03F0000000000000040', @wkb_writer.write_hex(geom, {
-        :include_srid => true
-      }))
+    assert_equal('0101000020E6100000000000000000F03F0000000000000040', @wkb_writer.write_hex(geom, {
+      :include_srid => true
+    }))
 
-      assert_equal('0101000000000000000000F03F0000000000000040', @wkb_writer.write_hex(geom))
-    end
+    assert_equal('0101000000000000000000F03F0000000000000040', @wkb_writer.write_hex(geom))
   end
 
   def test_illegal_output_dimensions

data/test/wkt_writer_tests.rb

@@ -18,139 +18,143 @@ class WktWriterTests < MiniTest::Unit::TestCase
     assert_in_delta(98.7654321, y, TOLERANCE)
   end
 
-  if ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:trim=)
-    def test_trim
-      geom = read('POINT(6 7)')
+  def test_trim
+    skip unless ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:trim=)
 
-      writer.trim = true
-      assert_equal('POINT (6 7)', write(geom))
+    geom = read('POINT(6 7)')
 
-      writer.trim = false
-      assert_equal('POINT (6.0000000000000000 7.0000000000000000)', write(geom))
-    end
+    writer.trim = true
+    assert_equal('POINT (6 7)', write(geom))
+
+    writer.trim = false
+    assert_equal('POINT (6.0000000000000000 7.0000000000000000)', write(geom))
+  end
 
-    def test_round_trip
-      writer.trim = true
-
-      [
-        'POINT (0 0)',
-        'POINT EMPTY',
-        'MULTIPOINT (0 1, 2 3)',
-        'MULTIPOINT EMPTY',
-        'LINESTRING (0 0, 2 3)',
-        'LINESTRING EMPTY',
-        'MULTILINESTRING ((0 1, 2 3), (10 10, 3 4))',
-        'MULTILINESTRING EMPTY',
-        'POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))',
-        'POLYGON EMPTY',
-        'MULTIPOLYGON (((0 0, 1 0, 1 1, 0 1, 0 0)), ((10 10, 10 14, 14 14, 14 10, 10 10), (11 11, 11 12, 12 12, 12 11, 11 11)))',
-        'MULTIPOLYGON EMPTY',
-        'GEOMETRYCOLLECTION (MULTIPOLYGON (((0 0, 1 0, 1 1, 0 1, 0 0)), ((10 10, 10 14, 14 14, 14 10, 10 10), (11 11, 11 12, 12 12, 12 11, 11 11))), POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0)), MULTILINESTRING ((0 0, 2 3), (10 10, 3 4)), LINESTRING (0 0, 2 3), MULTIPOINT (0 0, 2 3), POINT (9 0))',
-        'GEOMETRYCOLLECTION EMPTY'
-      ].each do |g|
-        assert_equal(g, write(read(g)))
-      end
+  def test_round_trip
+    skip unless ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:trim=)
+
+    writer.trim = true
+
+    [
+      'POINT (0 0)',
+      'POINT EMPTY',
+      'MULTIPOINT (0 1, 2 3)',
+      'MULTIPOINT EMPTY',
+      'LINESTRING (0 0, 2 3)',
+      'LINESTRING EMPTY',
+      'MULTILINESTRING ((0 1, 2 3), (10 10, 3 4))',
+      'MULTILINESTRING EMPTY',
+      'POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))',
+      'POLYGON EMPTY',
+      'MULTIPOLYGON (((0 0, 1 0, 1 1, 0 1, 0 0)), ((10 10, 10 14, 14 14, 14 10, 10 10), (11 11, 11 12, 12 12, 12 11, 11 11)))',
+      'MULTIPOLYGON EMPTY',
+      'GEOMETRYCOLLECTION (MULTIPOLYGON (((0 0, 1 0, 1 1, 0 1, 0 0)), ((10 10, 10 14, 14 14, 14 10, 10 10), (11 11, 11 12, 12 12, 12 11, 11 11))), POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0)), MULTILINESTRING ((0 0, 2 3), (10 10, 3 4)), LINESTRING (0 0, 2 3), MULTIPOINT (0 0, 2 3), POINT (9 0))',
+      'GEOMETRYCOLLECTION EMPTY'
+    ].each do |g|
+      assert_equal(g, write(read(g)))
     end
   end
 
-  if ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:rounding_precision=)
-    def test_rounding_precision
-      geom = read('POINT(6.123456 7.123456)')
+  def test_rounding_precision
+    skip unless ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:rounding_precision=)
 
-      tester = lambda { |expected, precision|
-        writer.rounding_precision = precision if precision
-        assert_equal(expected, write(geom))
-      }
+    geom = read('POINT(6.123456 7.123456)')
 
-      tester['POINT (6.1234560000000000 7.1234560000000000)', nil]
-      tester['POINT (6.12 7.12)', 2]
-      tester['POINT (6.12346 7.12346)', 5]
-      tester['POINT (6.1 7.1)', 1]
-      tester['POINT (6 7)', 0]
-    end
+    tester = lambda { |expected, precision|
+      writer.rounding_precision = precision if precision
+      assert_equal(expected, write(geom))
+    }
 
-    def test_rounding_precision_too_high
-      assert_raises(RuntimeError) do
-        @writer.rounding_precision = 1000
-      end
-    end
+    tester['POINT (6.1234560000000000 7.1234560000000000)', nil]
+    tester['POINT (6.12 7.12)', 2]
+    tester['POINT (6.12346 7.12346)', 5]
+    tester['POINT (6.1 7.1)', 1]
+    tester['POINT (6 7)', 0]
   end
 
-  if ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:output_dimensions)
-    def test_output_dimensions
-      assert_equal(2, writer.output_dimensions)
+  def test_rounding_precision_too_high
+    assert_raises(RuntimeError) do
+      @writer.rounding_precision = 1000
     end
   end
 
-  if ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:output_dimensions=)
-    def test_output_dimensions_set
-      geom_3d = read('POINT(1 2 3)')
-      geom_2d = read('POINT(3 2)')
+  def test_output_dimensions
+    skip unless ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:output_dimensions)
+
+    assert_equal(2, writer.output_dimensions)
+  end
+
+  def test_output_dimensions_set
+    skip unless ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:output_dimensions=)
 
-      writer.trim = true
+    geom_3d = read('POINT(1 2 3)')
+    geom_2d = read('POINT(3 2)')
 
-      # Only 2d by default
-      assert_equal('POINT (1 2)', write(geom_3d))
+    writer.trim = true
 
-      # 3d if requested _and_ available
-      writer.output_dimensions = 3
-      assert_equal('POINT Z (1 2 3)', write(geom_3d))
-      assert_equal('POINT (3 2)', write(geom_2d))
+    # Only 2d by default
+    assert_equal('POINT (1 2)', write(geom_3d))
 
-      # 1 is invalid
-      assert_raises(RuntimeError) do
-        writer.output_dimensions = 1
-      end
+    # 3d if requested _and_ available
+    writer.output_dimensions = 3
+    assert_equal('POINT Z (1 2 3)', write(geom_3d))
+    assert_equal('POINT (3 2)', write(geom_2d))
 
-      # 4 is invalid
-      assert_raises(RuntimeError) do
-        writer.output_dimensions = 4
-      end
+    # 1 is invalid
+    assert_raises(RuntimeError) do
+      writer.output_dimensions = 1
     end
 
-    def test_write_with_options
-      @writer.rounding_precision = 2
+    # 4 is invalid
+    assert_raises(RuntimeError) do
+      writer.output_dimensions = 4
+    end
+  end
 
-      geom = read('POINT(1 2 3)')
-      assert_equal('POINT (1 2)', write(geom, {
-        :trim => true
-      }))
+  def test_write_with_options
+    skip unless ENV['FORCE_TESTS'] || defined?(Geos::FFIGeos)
 
-      assert_equal('POINT (1.0000 2.0000)', write(geom, {
-        :rounding_precision => 4
-      }))
+    @writer.rounding_precision = 2
 
-      assert_equal('POINT Z (1 2 3)', write(geom, {
-        :output_dimensions => 3,
-        :trim => true
-      }))
+    geom = read('POINT(1 2 3)')
+    assert_equal('POINT (1 2)', write(geom, {
+      :trim => true
+    }))
 
-      assert_equal('POINT (1.00 2.00)', write(geom))
-    end
+    assert_equal('POINT (1.0000 2.0000)', write(geom, {
+      :rounding_precision => 4
+    }))
+
+    assert_equal('POINT Z (1 2 3)', write(geom, {
+      :output_dimensions => 3,
+      :trim => true
+    }))
+
+    assert_equal('POINT (1.00 2.00)', write(geom))
   end
 
-  if ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:old_3d=)
-    def test_old_3d_set
-      geom_3d = read('POINT(1 2 3)')
-      writer.trim = true
+  def test_old_3d_set
+    skip unless ENV['FORCE_TESTS'] || Geos::WktWriter.method_defined?(:old_3d=)
 
-      # New 3d WKT by default
-      writer.output_dimensions = 3
-      assert_equal('POINT Z (1 2 3)', write(geom_3d))
+    geom_3d = read('POINT(1 2 3)')
+    writer.trim = true
 
-      # Switch to old
-      writer.old_3d = true
-      assert_equal('POINT (1 2 3)', write(geom_3d))
+    # New 3d WKT by default
+    writer.output_dimensions = 3
+    assert_equal('POINT Z (1 2 3)', write(geom_3d))
 
-      # Old3d flag is not reset when changing dimensions
-      writer.output_dimensions = 2
-      assert_equal('POINT (1 2)', write(geom_3d))
-      writer.output_dimensions = 3
-      assert_equal('POINT (1 2 3)', write(geom_3d))
+    # Switch to old
+    writer.old_3d = true
+    assert_equal('POINT (1 2 3)', write(geom_3d))
 
-      # Likewise, dimensions spec is not reset when changing old3d flag
-      writer.old_3d = false
-      assert_equal('POINT Z (1 2 3)', write(geom_3d))
-    end
+    # Old3d flag is not reset when changing dimensions
+    writer.output_dimensions = 2
+    assert_equal('POINT (1 2)', write(geom_3d))
+    writer.output_dimensions = 3
+    assert_equal('POINT (1 2 3)', write(geom_3d))
+
+    # Likewise, dimensions spec is not reset when changing old3d flag
+    writer.old_3d = false
+    assert_equal('POINT Z (1 2 3)', write(geom_3d))
   end
 end