ffi-geos 1.2.0 → 2.2.0

data/test/prepared_geometry_tests.rb

@@ -1,7 +1,5 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
 require 'test_helper'
 
 class PreparedGeometryTests < Minitest::Test
@@ -19,14 +17,14 @@ class PreparedGeometryTests < Minitest::Test
 
   def relationship_tester(method, *expected)
     [
-      [ POINT_A, POINT_A ],
-      [ POINT_A, LINESTRING_A ],
-      [ POINT_B, LINESTRING_A ],
-      [ LINESTRING_B, LINESTRING_A ],
-      [ LINESTRING_C, LINESTRING_A ],
-      [ LINESTRING_D, LINESTRING_A ],
-      [ POLYGON_A, POLYGON_B ],
-      [ POLYGON_A, POINT_C ],
+      [POINT_A, POINT_A],
+      [POINT_A, LINESTRING_A],
+      [POINT_B, LINESTRING_A],
+      [LINESTRING_B, LINESTRING_A],
+      [LINESTRING_C, LINESTRING_A],
+      [LINESTRING_D, LINESTRING_A],
+      [POLYGON_A, POLYGON_B],
+      [POLYGON_A, POINT_C]
     ].each_with_index do |(geom_a, geom_b), i|
       geom_a = read(geom_a).to_prepared
       geom_b = read(geom_b)
@@ -114,4 +112,3 @@ class PreparedGeometryTests < Minitest::Test
     end
   end
 end
-

data/test/strtree_tests.rb

@@ -1,7 +1,5 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
 require 'test_helper'
 
 class STRtreeTests < Minitest::Test
@@ -9,8 +7,8 @@ class STRtreeTests < Minitest::Test
 
   def setup_tree
     @tree = Geos::STRtree.new(3)
-    @item_1 = { :item_1 => :test }
-    @item_2 = [ :test ]
+    @item_1 = { item_1: :test }
+    @item_2 = [:test]
     @item_3 = Object.new
 
     @geom_1 = read('LINESTRING(0 0, 10 10)')
@@ -83,7 +81,7 @@ class STRtreeTests < Minitest::Test
 
     assert_equal(
       [
-        { :item => @item_1, :geometry => @geom_1 }
+        { item: @item_1, geometry: @geom_1 }
       ],
       @tree.query(read('LINESTRING(5 5, 6 6)'), :all)
     )
@@ -93,17 +91,17 @@ class STRtreeTests < Minitest::Test
 
     assert_equal(
       [
-        { :item => @item_2, :geometry => @geom_2 },
-        { :item => @item_3, :geometry => @geom_3 }
+        { item: @item_2, geometry: @geom_2 },
+        { item: @item_3, geometry: @geom_3 }
       ],
       @tree.query(read('LINESTRING(25 25, 26 26)'), :all)
     )
 
     assert_equal(
       [
-        { :item => @item_1, :geometry => @geom_1 },
-        { :item => @item_2, :geometry => @geom_2 },
-        { :item => @item_3, :geometry => @geom_3 }
+        { item: @item_1, geometry: @geom_1 },
+        { item: @item_2, geometry: @geom_2 },
+        { item: @item_3, geometry: @geom_3 }
       ],
       @tree.query(read('LINESTRING(0 0, 100 100)'), :all)
     )
@@ -185,9 +183,9 @@ class STRtreeTests < Minitest::Test
     skip unless ENV['FORCE_TESTS'] || defined?(Geos::STRtree)
 
     tree = Geos::STRtree.new(
-      [ read('LINESTRING(0 0, 10 10)'), item_1 = { :item_1 => :test } ],
-      [ read('LINESTRING(20 20, 30 30)'), item_2 = [ :test ] ],
-      [ read('LINESTRING(20 20, 30 30)'), item_3 = Object.new ]
+      [read('LINESTRING(0 0, 10 10)'), item_1 = { item_1: :test }],
+      [read('LINESTRING(20 20, 30 30)'), item_2 = [:test]],
+      [read('LINESTRING(20 20, 30 30)'), item_3 = Object.new]
     )
 
     assert_equal([item_1],
@@ -315,6 +313,7 @@ class STRtreeTests < Minitest::Test
 
   def test_nearest_with_only_empty_geometries
     skip unless ENV['FORCE_TESTS'] || defined?(Geos::STRtree) && Geos::STRtree.method_defined?(:nearest)
+    skip if Geos::GEOS_VERSION > '3.9.0'
 
     geom_1 = read('LINESTRING EMPTY')
     geom_2 = read('POINT (2 7)')
@@ -347,8 +346,8 @@ class STRtreeTests < Minitest::Test
     geom_3 = read('POINT (5 4)')
     geom_4 = read('POINT (3 8)')
 
-    item_1 = { :item_1 => :test }
-    item_2 = [ :test ]
+    item_1 = { item_1: :test }
+    item_2 = [:test]
     item_3 = Object.new
 
     tree = Geos::STRtree.new(2)

data/test/test_helper.rb

@@ -1,20 +1,17 @@
-# encoding: BINARY
 # frozen_string_literal: true
 
-if RUBY_VERSION >= '1.9'
-  require 'simplecov'
+require 'simplecov'
 
-  SimpleCov.command_name('Unit Tests')
-  SimpleCov.merge_timeout(3600)
-  SimpleCov.start do
-    add_filter '/test/'
-    add_filter '/.bundle/'
-  end
+SimpleCov.command_name('Unit Tests')
+SimpleCov.merge_timeout(3600)
+SimpleCov.start do
+  add_filter '/test/'
+  add_filter '/.bundle/'
 end
 
 require 'rubygems'
 require 'minitest/autorun'
-require 'minitest/reporters' if RUBY_VERSION >= '1.9'
+require 'minitest/reporters'
 
 if ENV['USE_BINARY_GEOS']
   require 'geos'
@@ -32,14 +29,21 @@ else
 end
 
 puts "ffi-geos version #{Geos::VERSION}" if defined?(Geos::VERSION)
-
-if defined?(Geos::FFIGeos)
-  puts "Using #{Geos::FFIGeos.geos_library_path}"
-end
+puts "Using #{Geos::FFIGeos.geos_library_path}" if defined?(Geos::FFIGeos)
 
 module TestHelper
   TOLERANCE = 0.0000000000001
 
+  EMPTY_GEOMETRY = if Geos::GEOS_VERSION > '3.8'
+    'POINT EMPTY'
+  else
+    'GEOMETRYCOLLECTION EMPTY'
+  end
+
+  EMPTY_BLOCK = proc do
+    nil
+  end
+
   def self.included(base)
     base.class_eval do
       attr_reader :reader, :reader_hex, :writer
@@ -53,16 +57,16 @@ module TestHelper
     @writer = Geos::WktWriter.new
   end
 
-  def read(*args)
-    if args[0][0] != '0'
-      reader.read(*args)
+  def read(*args, **options)
+    if args[0][0] == '0'
+      reader_hex.read_hex(*args, **options)
     else
-      reader_hex.read_hex(*args)
+      reader.read(*args, **options)
     end
   end
 
-  def write(*args)
-    writer.write(*args)
+  def write(*args, **options)
+    writer.write(*args, **options)
   end
 
   def geom_from_geom_or_wkt(geom_or_wkt)
@@ -73,11 +77,11 @@ module TestHelper
     end
   end
 
-  def srid_copy_tester(method, expected, expected_srid, srid_policy, wkt, *args)
+  def srid_copy_tester(method, expected, expected_srid, srid_policy, wkt, *args, **options)
     geom = read(wkt)
     geom.srid = 4326
     Geos.srid_copy_policy = srid_policy
-    geom_b = geom.send(method, *args)
+    geom_b = geom.send(method, *args, **options)
     assert_equal(4326, geom.srid)
     assert_equal(expected_srid, geom_b.srid)
     assert_equal(expected, write(geom_b))
@@ -86,14 +90,14 @@ module TestHelper
   end
 
   {
-    :empty => 'to be empty',
-    :valid => 'to be valid',
-    :simple => 'to be simple',
-    :ring => 'to be ring',
-    :closed => 'to be closed',
-    :has_z => 'to have z dimension'
+    empty: 'to be empty',
+    valid: 'to be valid',
+    simple: 'to be simple',
+    ring: 'to be ring',
+    closed: 'to be closed',
+    has_z: 'to have z dimension'
   }.each do |t, m|
-    self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+    class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
       def assert_geom_#{t}(geom)
         assert(geom.#{t}?, "Expected geom #{m}")
       end
@@ -101,62 +105,82 @@ module TestHelper
       def refute_geom_#{t}(geom)
         assert(!geom.#{t}?, "Did not expect geom #{m}")
       end
-    EOF
+    RUBY
   end
 
   def assert_geom_eql_exact(geom, result, tolerance = TOLERANCE)
     assert(geom.eql_exact?(result, tolerance), "Expected geom.eql_exact? to be within #{tolerance}")
   end
 
-  def simple_tester(method, expected, geom, *args)
+  def snapped_tester(method, expected, geom, *args, **options)
     geom = geom_from_geom_or_wkt(geom)
-    result = geom.send(method, *args)
 
-    if result.is_a?(Geos::Geometry)
-      result = write(result)
-    end
+    result = geom.send(method, *args, **options)
+    assert_equal(expected, write(result.snap_to_grid(1)))
+  end
 
-    assert_equal(expected, result)
+  def simple_tester(method, expected, geom, *args, **options)
+    geom = geom_from_geom_or_wkt(geom)
+    result = geom.send(method, *args, **options)
+    result = write(result) if result.is_a?(Geos::Geometry)
+
+    if expected.nil?
+      assert_nil(result)
+    else
+      assert_equal(expected, result)
+    end
   end
 
-  def simple_bang_tester(method, expected, wkt, *args)
+  def simple_bang_tester(method, expected, wkt, *args, **options)
     geom = read(wkt)
-    result = geom.send(method, *args)
+    result = geom.send(method, *args, **options)
 
     assert_equal(wkt, write(geom))
     assert_equal(expected, write(result))
 
     geom = read(wkt)
-    geom.send("#{method}!", *args)
+    geom.send("#{method}!", *args, **options)
 
     assert_equal(expected, write(geom))
   end
 
-  def comparison_tester(method, expected, geom_a, geom_b, *args)
-    geom_a = geom_from_geom_or_wkt(geom_a)
-    geom_b = geom_from_geom_or_wkt(geom_b)
+  def comparison_tester(method, expected, geom_a, geom_b, *args, **options)
+    geom_a = geom_from_geom_or_wkt(geom_a).normalize
+    geom_b = geom_from_geom_or_wkt(geom_b).normalize
 
-    simple_tester(method, expected, geom_a, geom_b, *args)
+    simple_tester(method, expected, geom_a, geom_b, *args, **options)
   end
 
-  def array_tester(method, expected, geom, *args)
+  def array_tester(method, expected, geom, *args, **options)
     geom = geom_from_geom_or_wkt(geom)
-    result = geom.send(method, *args)
+    result = geom.send(method, *args, **options)
 
     case result
       when Geos::Geometry
-        result = [ write(result) ]
+        result = [write(result)]
       when Array
-        result = result.collect { |r|
+        result = result.collect do |r|
           write(r)
-        }
+        end
     end
 
     assert_equal(expected, result)
   end
-end
 
-if RUBY_VERSION >= '1.9'
-  Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)
+  def affine_tester(method, expected, wkt, *args, **options)
+    writer.trim = true
+
+    geom = read(wkt)
+    geom.send("#{method}!", *args, **options).snap_to_grid!(0.1)
+
+    assert_equal(expected, write(geom))
+
+    geom = read(wkt)
+    geom_2 = geom.send(method, *args, **options).snap_to_grid(0.1)
+
+    assert_equal(wkt, write(geom))
+    assert_equal(expected, write(geom_2, trim: true))
+  end
 end
 
+Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)

data/test/tools_tests.rb

@@ -1,7 +1,5 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
 require 'test_helper'
 
 class ToolsTests < Minitest::Test
@@ -25,7 +23,7 @@ class ToolsTests < Minitest::Test
   def test_bool_to_int
     assert_equal(1, Geos::Tools.bool_to_int(1))
     assert_equal(1, Geos::Tools.bool_to_int(true))
-    assert_equal(1, Geos::Tools.bool_to_int(""))
+    assert_equal(1, Geos::Tools.bool_to_int(''))
     assert_equal(1, Geos::Tools.bool_to_int(0))
     assert_equal(0, Geos::Tools.bool_to_int(false))
     assert_equal(0, Geos::Tools.bool_to_int(nil))
@@ -92,4 +90,3 @@ class ToolsTests < Minitest::Test
     assert_equal(:round, Geos::Tools.symbol_for_enum(Geos::BufferCapStyles, 1))
   end
 end
-

data/test/utils_tests.rb

@@ -1,7 +1,5 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
 require 'test_helper'
 
 class UtilsTests < Minitest::Test
@@ -15,17 +13,17 @@ class UtilsTests < Minitest::Test
   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))
+    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, 1_000_000, 1_000_001))
+    assert_equal(-1, Geos::Utils.orientation_index(0, 0, 10, 10, 1_000_000, 999_999))
   end
 
   def test_relate_match
@@ -50,7 +48,7 @@ class UtilsTests < Minitest::Test
   end
 
   def test_create_point
-    cs = Geos::CoordinateSequence.new([[ 10, 20 ]])
+    cs = Geos::CoordinateSequence.new([[10, 20]])
     create_method_tester('POINT (10 20)', :create_point, cs, Geos::GEOS_POINT, Geos::Point)
   end
 
@@ -59,7 +57,7 @@ class UtilsTests < Minitest::Test
   end
 
   def test_create_point_with_x_y_and_z_arguments
-    assert_equal('POINT Z (10 20 30)', write(Geos.create_point(10, 20, 30), :output_dimensions => 3))
+    assert_equal('POINT Z (10 20 30)', write(Geos.create_point(10, 20, 30), output_dimensions: 3))
   end
 
   def test_create_point_with_too_many_arguments
@@ -77,8 +75,8 @@ class UtilsTests < Minitest::Test
 
   def test_create_line_string
     cs = Geos::CoordinateSequence.new([
-     [ 10, 20, 30 ],
-     [ 30, 20, 10 ]
+      [10, 20, 30],
+      [30, 20, 10]
     ])
 
     writer.output_dimensions = 3
@@ -105,7 +103,7 @@ class UtilsTests < Minitest::Test
     create_method_tester(
       'LINESTRING Z (10 20 30, 30 20 10)',
       :create_line_string,
-      [[ 10, 20, 30 ], [ 30, 20, 10 ]],
+      [[10, 20, 30], [30, 20, 10]],
       Geos::GEOS_LINESTRING,
       Geos::LineString
     ) do |geom|
@@ -121,16 +119,16 @@ class UtilsTests < Minitest::Test
   def test_create_bad_line_string
     cs = Geos::CoordinateSequence.new(1, 0)
     assert_raises(ArgumentError) do
-      Geos::create_line_string(cs)
+      Geos.create_line_string(cs)
     end
   end
 
   def test_create_linear_ring
     cs = Geos::CoordinateSequence.new([
-      [ 7, 8, 9 ],
-      [ 3, 3, 3 ],
-      [ 11, 15.2, 2 ],
-      [ 7, 8, 9 ]
+      [7, 8, 9],
+      [3, 3, 3],
+      [11, 15.2, 2],
+      [7, 8, 9]
     ])
 
     writer.output_dimensions = 3
@@ -157,7 +155,7 @@ class UtilsTests < Minitest::Test
     create_method_tester(
       'LINEARRING Z (7 8 9, 3 3 3, 11 15.2 2, 7 8 9)',
       :create_linear_ring,
-      [[ 7, 8, 9 ], [ 3, 3, 3 ], [ 11, 15.2, 2 ], [ 7, 8, 9 ]],
+      [[7, 8, 9], [3, 3, 3], [11, 15.2, 2], [7, 8, 9]],
       Geos::GEOS_LINEARRING,
       Geos::LinearRing
     ) do |geom|
@@ -174,22 +172,22 @@ class UtilsTests < Minitest::Test
     cs = Geos::CoordinateSequence.new(1, 0)
 
     assert_raises(ArgumentError) do
-      Geos::create_linear_ring(cs)
+      Geos.create_linear_ring(cs)
     end
   end
 
   def test_create_polygon
     cs = Geos::CoordinateSequence.new([
-      [ 0, 0 ],
-      [ 0, 10 ],
-      [ 10, 10 ],
-      [ 10, 0 ],
-      [ 0, 0 ]
+      [0, 0],
+      [0, 10],
+      [10, 10],
+      [10, 0],
+      [0, 0]
     ])
 
-    exterior_ring = Geos::create_linear_ring(cs)
+    exterior_ring = Geos.create_linear_ring(cs)
 
-    geom = Geos::create_polygon(exterior_ring)
+    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)
@@ -198,22 +196,22 @@ class UtilsTests < Minitest::Test
 
   def test_create_polygon_with_coordinate_sequences
     outer = Geos::CoordinateSequence.new(
-      [ 0, 0 ],
-      [ 0, 10 ],
-      [ 10, 10 ],
-      [ 10, 0 ],
-      [ 0, 0 ]
+      [0, 0],
+      [0, 10],
+      [10, 10],
+      [10, 0],
+      [0, 0]
     )
 
     inner = Geos::CoordinateSequence.new(
-      [ 2, 2 ],
-      [ 2, 4 ],
-      [ 4, 4 ],
-      [ 4, 2 ],
-      [ 2, 2 ]
+      [2, 2],
+      [2, 4],
+      [4, 4],
+      [4, 2],
+      [2, 2]
     )
 
-    geom = Geos::create_polygon(outer, inner)
+    geom = Geos.create_polygon(outer, inner)
     assert_instance_of(Geos::Polygon, geom)
     assert_equal('Polygon', geom.geom_type)
     assert_equal(Geos::GEOS_POLYGON, geom.type_id)
@@ -222,30 +220,30 @@ class UtilsTests < Minitest::Test
 
   def test_create_polygon_with_holes
     exterior_ring = Geos::CoordinateSequence.new(
-      [ 0, 0 ],
-      [ 0, 10 ],
-      [ 10, 10 ],
-      [ 10, 0 ],
-      [ 0, 0 ]
+      [0, 0],
+      [0, 10],
+      [10, 10],
+      [10, 0],
+      [0, 0]
     )
 
     hole_1 = Geos::CoordinateSequence.new(
-      [ 2, 2 ],
-      [ 2, 4 ],
-      [ 4, 4 ],
-      [ 4, 2 ],
-      [ 2, 2 ]
+      [2, 2],
+      [2, 4],
+      [4, 4],
+      [4, 2],
+      [2, 2]
     )
 
     hole_2 = Geos::CoordinateSequence.new(
-      [ 6, 6 ],
-      [ 6, 8 ],
-      [ 8, 8 ],
-      [ 8, 6 ],
-      [ 6, 6 ]
+      [6, 6],
+      [6, 8],
+      [8, 8],
+      [8, 6],
+      [6, 6]
     )
 
-    geom = Geos::create_polygon(exterior_ring, [ hole_1, hole_2 ])
+    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)
@@ -263,10 +261,13 @@ class UtilsTests < Minitest::Test
     skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_multi_point)
 
     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)')
-    )))
+    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
@@ -284,10 +285,13 @@ class UtilsTests < Minitest::Test
     skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_multi_line_string)
 
     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)')
-    )))
+    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
@@ -305,10 +309,13 @@ class UtilsTests < Minitest::Test
     skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_multi_polygon)
 
     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))')
-    )))
+    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
@@ -327,11 +334,12 @@ class UtilsTests < Minitest::Test
 
     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))')
+      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_geometry_collection_with_constants_and_symbols
@@ -356,7 +364,7 @@ class UtilsTests < Minitest::Test
   def test_create_geometry_collection_with_options
     skip unless ENV['FORCE_TESTS'] || Geos.respond_to?(:create_geometry_collection)
 
-    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)
@@ -441,6 +449,7 @@ class UtilsTests < Minitest::Test
         [5, 5],
         [0, 5]
       ])
+
       Geos.create_linear_ring(cs)
       GC.start
     end