ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/spec/unit/gdal/raster_band_mixins/extensions_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'gdal/driver'
+require 'gdal/raster_band'
+
+RSpec.describe 'GDAL::RasterBandMixins::Extensions' do
+  let(:driver) { GDAL::Driver.by_name('MEM') }
+  let(:dataset_byte) { driver.create_dataset('test', 15, 25, data_type: :GDT_Byte) }
+  subject(:raster_band) { dataset_byte.raster_band(1) }
+
+  describe '#to_a' do
+    subject { raster_band.to_a }
+    it { is_expected.to eq(Array.new(25, Array.new(15, 0))) }
+  end
+
+  describe '#to_na' do
+    context 'no conversion' do
+      subject { raster_band.to_na }
+      it { is_expected.to eq(NArray.byte(15, 25)) }
+    end
+
+    context 'convert to Int16' do
+      subject { raster_band.to_na(:GDT_Int16) }
+      it { is_expected.to eq(NArray.sint(15, 25)) }
+    end
+
+    context 'convert to UInt16' do
+      subject { raster_band.to_na(:GDT_UInt16) }
+      it { is_expected.to eq(NArray.int(15, 25)) }
+    end
+
+    context 'convert to Int32' do
+      subject { raster_band.to_na(:GDT_Int32) }
+      it { is_expected.to eq(NArray.int(15, 25)) }
+    end
+
+    context 'convert to UInt32' do
+      subject { raster_band.to_na(:GDT_UInt32) }
+      it { is_expected.to eq(NArray.int(15, 25)) }
+    end
+
+    context 'convert to Float32' do
+      subject { raster_band.to_na(:GDT_Float32) }
+      it { is_expected.to eq(NArray.sfloat(15, 25)) }
+    end
+
+    context 'convert to Float64' do
+      subject { raster_band.to_na(:GDT_Float64) }
+      it { is_expected.to eq(NArray.float(15, 25)) }
+    end
+
+    context 'convert to CInt16' do
+      subject { raster_band.to_na(:GDT_CInt16) }
+      it { is_expected.to eq(NArray.scomplex(15, 25)) }
+    end
+
+    context 'convert to CInt32' do
+      subject { raster_band.to_na(:GDT_CInt32) }
+      it { is_expected.to eq(NArray.scomplex(15, 25)) }
+    end
+
+    context 'convert to CFloat32' do
+      subject { raster_band.to_na(:GDT_CFloat32) }
+      it { is_expected.to eq(NArray.scomplex(15, 25)) }
+    end
+
+    context 'convert to CFloat64' do
+      subject { raster_band.to_na(:GDT_CFloat64) }
+      it { is_expected.to eq(NArray.complex(15, 25)) }
+    end
+  end
+end

data/spec/unit/gdal/raster_band_mixins/io_extensions_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'gdal/driver'
+require 'gdal/raster_band'
+
+RSpec.describe 'GDAL::RasterBandMixins::IOExtensions' do
+  let(:driver) { GDAL::Driver.by_name('MEM') }
+  let(:dataset_byte) { driver.create_dataset('test', 15, 25, data_type: :GDT_Byte) }
+  let(:dataset_int16) { driver.create_dataset('test', 15, 25, data_type: :GDT_Int16) }
+  let(:dataset_uint16) { driver.create_dataset('test', 15, 25, data_type: :GDT_UInt16) }
+  let(:dataset_int32) { driver.create_dataset('test', 15, 25, data_type: :GDT_Int32) }
+  let(:dataset_uint32) { driver.create_dataset('test', 15, 25, data_type: :GDT_UInt32) }
+  let(:dataset_float32) { driver.create_dataset('test', 15, 25, data_type: :GDT_Float32) }
+  let(:dataset_float64) { driver.create_dataset('test', 15, 25, data_type: :GDT_Float64) }
+
+  subject(:raster_band) { dataset_byte.raster_band(1) }
+
+  describe '#write_xy_narray' do
+    let(:dataset) { driver.create_dataset('test dataset', 64, 4) }
+    let(:raster_band) { dataset.raster_band 1 }
+
+    it 'writes pixels from the NArray' do
+      row0 = Array.new(64) { 1 }
+      row1 = Array.new(64) { 2 }
+      row2 = Array.new(64) { 3 }
+      row3 = Array.new(64) { 4 }
+      narray = NArray[row0, row1, row2, row3]
+
+      raster_band.write_xy_narray(narray)
+
+      pixels = raster_band.to_na
+      expect(pixels[true, 0]).to eq(NArray.to_na(row0))
+      expect(pixels[true, 1]).to eq(NArray.to_na(row1))
+      expect(pixels[true, 2]).to eq(NArray.to_na(row2))
+      expect(pixels[true, 3]).to eq(NArray.to_na(row3))
+    end
+  end
+
+  describe '#set_pixel_value/#pixel_value' do
+    context 'valid values, GDT_Byte' do
+      it 'sets and gets the value successfully' do
+        subject.set_pixel_value(0, 0, 123)
+        expect(subject.pixel_value(0, 0)).to eq(123)
+      end
+    end
+
+    context 'valid values, GDT_Int16' do
+      subject { dataset_int16.raster_band(1) }
+
+      it 'sets and gets the value successfully' do
+        subject.set_pixel_value(0, 0, -12_345)
+        expect(subject.pixel_value(0, 0)).to eq(-12_345)
+      end
+    end
+
+    context 'valid values, GDT_UInt16' do
+      subject { dataset_uint16.raster_band(1) }
+
+      it 'sets and gets the value successfully' do
+        subject.set_pixel_value(0, 0, 32_123)
+        expect(subject.pixel_value(0, 0)).to eq(32_123)
+      end
+    end
+
+    context 'valid values, GDT_Int32' do
+      subject { dataset_int32.raster_band(1) }
+
+      it 'sets and gets the value successfully' do
+        subject.set_pixel_value(0, 0, -123_456_789)
+        expect(subject.pixel_value(0, 0)).to eq(-123_456_789)
+      end
+    end
+
+    context 'valid values, GDT_UInt32' do
+      subject { dataset_uint32.raster_band(1) }
+
+      it 'sets and gets the value successfully' do
+        subject.set_pixel_value(0, 0, 4_123_456_789)
+        expect(subject.pixel_value(0, 0)).to eq(4_123_456_789)
+      end
+    end
+
+    context 'valid values, GDT_Float32' do
+      subject { dataset_float32.raster_band(1) }
+
+      # For some reason, precision of float32 values isn't there past a couple
+      # decimals when reading back.
+      it 'sets and gets the value successfully' do
+        subject.set_pixel_value(0, 0, -123.456)
+        expect(subject.pixel_value(0, 0)).to be_within(0.001).of(-123.456)
+      end
+    end
+
+    context 'valid values, GDT_Float64' do
+      subject { dataset_float64.raster_band(1) }
+
+      it 'sets and gets the value successfully' do
+        subject.set_pixel_value(0, 0, -123_456_789_101.456)
+        expect(subject.pixel_value(0, 0)).to eq(-123_456_789_101.456)
+      end
+    end
+  end
+
+  describe '#block_count' do
+    it 'returns a Hash of relevant values' do
+      expect(subject.block_count).to eq(
+        x: 1,
+        x_remainder: 0,
+        y: 25,
+        y_remainder: 0
+      )
+    end
+  end
+
+  describe '#block_buffer_size' do
+    subject { raster_band.block_buffer_size }
+    it { is_expected.to eq(15) }
+  end
+
+  describe '#read_lines_by_block' do
+    context 'block is given' do
+      it 'yields each row of pixels' do
+        expect { |b| subject.read_lines_by_block(&b) }.
+          to yield_successive_args(*Array.new(25, Array.new(15, 0)))
+      end
+    end
+
+    context 'no block given' do
+      it 'returns an Enumerator' do
+        expect(subject.read_lines_by_block).to be_a(Enumerator)
+      end
+    end
+  end
+end

data/spec/unit/gdal/raster_band_spec.rb

@@ -2,4 +2,5 @@ require 'spec_helper'
 require 'gdal/raster_band'
 
 RSpec.describe GDAL::RasterBand do
+  pending 'Add some tests!'
 end

data/spec/unit/gdal/rpc_info_spec.rb

@@ -2,4 +2,5 @@ require 'spec_helper'
 require 'gdal/rpc_info'
 
 RSpec.describe GDAL::RPCInfo do
+  pending 'Add some tests!'
 end

data/spec/unit/gdal/version_info_spec.rb

@@ -3,4 +3,6 @@ require 'gdal/version_info'
 
 RSpec.describe GDAL::VersionInfo do
   subject { Object.new.extend(described_class) }
+
+  pending 'Add some tests!'
 end

data/spec/unit/gdal/warp_operation_spec.rb

@@ -2,4 +2,5 @@ require 'spec_helper'
 require 'gdal/warp_operation'
 
 RSpec.describe GDAL::WarpOperation do
+  pending 'Add some tests!'
 end

data/spec/unit/ogr/coordinate_transformation_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'ogr/coordinate_transformation'
+
+RSpec.describe OGR::CoordinateTransformation do
+  let(:source_srs) { OGR::SpatialReference.new_from_epsg(3857) }
+  let(:dest_srs) { OGR::SpatialReference.new_from_epsg(4326) }
+
+  # From https://epsg.io/3857
+  let(:epsg4326_y_bounds) { [-85.06, 85.06] }
+  let(:epsg4326_x_bounds) { [-180.0, 180.0] }
+  let(:epsg3857_y_bounds) { [-20_048_966.10, 20_048_966.10] }
+  let(:epsg3857_x_bounds) { [-20_026_376.39, 20_026_376.39] }
+
+  subject { described_class.new(source_srs, dest_srs) }
+
+  describe '.proj4_normalize' do
+    context 'OCTProj4Normalize not supported' do
+      it 'raises a OGR::UnsupportedOperation' do
+        expect { described_class.proj4_normalize('asdf') }.to raise_exception(OGR::UnsupportedOperation)
+      end
+    end
+  end
+
+  describe '#initialize' do
+    context 'source_srs is not an OGR::SpatialReference' do
+      it 'raises an OGR::Failure' do
+        expect { described_class.new(123, dest_srs) }.to raise_exception(OGR::Failure)
+      end
+    end
+
+    context 'dest_srs is not an OGR::SpatialReference' do
+      it 'raises an OGR::Failure' do
+        expect { described_class.new(source_srs, 123) }.to raise_exception(OGR::Failure)
+      end
+    end
+
+    context 'source_srs and dest_srs are valid OGR::SpatialReference objects' do
+      it 'creates a new object with @c_pointer set' do
+        instance = described_class.new(source_srs, dest_srs)
+        expect(instance).to be_a described_class
+        expect(instance.c_pointer).to be_a FFI::Pointer
+      end
+    end
+  end
+
+  describe '#destroy!' do
+    it 'sets @c_pointer to nil' do
+      subject.destroy!
+      expect(subject.c_pointer).to be_nil
+    end
+  end
+
+  describe '#transform' do
+    context 'no z_vertices, valid x and y vertices' do
+      it 'transforms the points' do
+        result = subject.transform(epsg3857_x_bounds, epsg3857_y_bounds)
+
+        transformed_x_points = result.first
+        transformed_y_points = result.last
+
+        expect(transformed_x_points.first).to be_within(0.11).of(epsg4326_x_bounds.first)
+        expect(transformed_x_points.last).to be_within(0.11).of(epsg4326_x_bounds.last)
+        expect(transformed_y_points.first).to be_within(0.001).of(epsg4326_y_bounds.first)
+        expect(transformed_y_points.last).to be_within(0.001).of(epsg4326_y_bounds.last)
+      end
+    end
+
+    context 'valid x, y, and z vertices' do
+      it 'transforms the points' do
+        result = subject.transform(epsg3857_x_bounds, epsg3857_y_bounds, [10_000, -299])
+
+        transformed_x_points = result.first
+        transformed_y_points = result[1]
+        transformed_z_points = result.last
+
+        expect(transformed_x_points.first).to be_within(0.11).of(epsg4326_x_bounds.first)
+        expect(transformed_x_points.last).to be_within(0.11).of(epsg4326_x_bounds.last)
+        expect(transformed_y_points.first).to be_within(0.001).of(epsg4326_y_bounds.first)
+        expect(transformed_y_points.last).to be_within(0.001).of(epsg4326_y_bounds.last)
+        expect(transformed_z_points.first).to eq(10_000)
+        expect(transformed_z_points.last).to eq(-299)
+      end
+    end
+  end
+
+  describe '#transform_ex' do
+    context 'no z_vertices, valid x and y vertices' do
+      it 'transforms the points' do
+        result = subject.transform_ex(epsg3857_x_bounds, epsg3857_y_bounds)
+
+        transformed_x_points = result[:points].first
+        transformed_y_points = result[:points].last
+
+        expect(transformed_x_points.first).to be_within(0.11).of(epsg4326_x_bounds.first)
+        expect(transformed_x_points.last).to be_within(0.11).of(epsg4326_x_bounds.last)
+        expect(transformed_y_points.first).to be_within(0.001).of(epsg4326_y_bounds.first)
+        expect(transformed_y_points.last).to be_within(0.001).of(epsg4326_y_bounds.last)
+        expect(result[:successes]).to eq([true, false])
+      end
+    end
+  end
+end

data/spec/unit/ogr/data_source_spec.rb

@@ -11,6 +11,18 @@ RSpec.describe OGR::DataSource do
         end.to raise_exception OGR::OpenFailure
       end
     end
+
+    context 'block given' do
+      let(:data_source) { instance_double 'OGR::DataSource' }
+
+      it 'yields then closes the opened DataSource' do
+        allow(described_class).to receive(:new).and_return data_source
+
+        expect(data_source).to receive(:close)
+        expect { |b| described_class.open('blarg', 'r', &b) }.
+          to yield_with_args(data_source)
+      end
+    end
   end
 
   let(:driver) { OGR::Driver.by_name 'Memory' }

data/spec/unit/ogr/feature_extensions_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'ogr'
+
+RSpec.describe OGR::Feature do
+  let(:integer_field_def) { OGR::FieldDefinition.new('test integer field', :OFTInteger) }
+
+  let(:feature_definition) do
+    fd = OGR::FeatureDefinition.new('test FD')
+    fd.add_field_definition(integer_field_def)        # 0
+
+    gfd = fd.geometry_field_definition(0)
+    gfd.type = :wkbPoint
+    gfd.name = 'test point'
+
+    fd
+  end
+
+  let(:geometry) { OGR::Point.create_from_wkt('POINT (0 1)') }
+
+  subject(:feature) do
+    f = described_class.new(feature_definition)
+    f.set_geometry_field(0, geometry)
+
+    f
+  end
+
+  describe '#each_field' do
+    context 'no block given' do
+      it 'returns an Enumerator' do
+        expect(subject.each_field).to be_a Enumerator
+      end
+    end
+
+    context 'block given' do
+      it 'yields each geometry field definition' do
+        expect { |b| subject.each_field(&b) }.to yield_successive_args(0)
+      end
+    end
+  end
+
+  describe '#fields' do
+    it 'returns all of the field values as an Array' do
+      expect(subject.fields).to eq [0]
+    end
+  end
+
+  describe '#each_geometry_field_definition' do
+    context 'no block given' do
+      it 'returns an Enumerator' do
+        expect(subject.each_geometry_field_definition).to be_a Enumerator
+      end
+    end
+
+    context 'block given' do
+      it 'yields each geometry field definition' do
+        expect { |b| subject.each_geometry_field_definition(&b) }.
+          to yield_successive_args(OGR::GeometryFieldDefinition)
+      end
+    end
+  end
+
+  describe '#geometry_field_definitions' do
+    it 'returns all of the geometry field definitions as an Array of GeometryFieldDefinitions' do
+      expect(subject.geometry_field_definitions).to contain_exactly instance_of(OGR::GeometryFieldDefinition)
+    end
+  end
+
+  describe '#each_geometry_field' do
+    context 'no block given' do
+      it 'returns an Enumerator' do
+        expect(subject.each_geometry_field).to be_a Enumerator
+      end
+    end
+
+    context 'block given' do
+      it 'yields each geometry field' do
+        expect { |b| subject.each_geometry_field(&b) }.
+          to yield_successive_args(geometry)
+      end
+    end
+  end
+
+  describe '#geometry_fields' do
+    it 'returns all of the geometry fields as an Array of Geometries' do
+      expect(subject.geometry_fields).to eq [geometry]
+    end
+  end
+end

data/spec/unit/ogr/feature_spec.rb

@@ -1,34 +1,33 @@
 require 'spec_helper'
 require 'date'
 require 'ogr/feature'
+require 'ogr/field'
 
 RSpec.describe OGR::Feature do
-  let(:integer_field) { OGR::FieldDefinition.new('test integer field', :OFTInteger) }
-  let(:integer_list_field) { OGR::FieldDefinition.new('test integer list field', :OFTIntegerList) }
-  let(:real_field) { OGR::FieldDefinition.new('test real field', :OFTReal) }
-  let(:real_list_field) { OGR::FieldDefinition.new('test real list field', :OFTRealList) }
-  let(:string_field) { OGR::FieldDefinition.new('test string field', :OFTString) }
-  let(:string_list_field) { OGR::FieldDefinition.new('test string list field', :OFTStringList) }
-  let(:binary_field) { OGR::FieldDefinition.new('test binary field', :OFTBinary) }
-  let(:date_field) { OGR::FieldDefinition.new('test date field', :OFTDate) }
-
-  let(:geometry_field_definition) do
-    OGR::GeometryFieldDefinition.new('test geometry', :wkbPoint)
-  end
+  let(:integer_field_def) { OGR::FieldDefinition.new('test integer field', :OFTInteger) }
+  let(:integer_list_field_def) { OGR::FieldDefinition.new('test integer list field', :OFTIntegerList) }
+  let(:real_field_def) { OGR::FieldDefinition.new('test real field', :OFTReal) }
+  let(:real_list_field_def) { OGR::FieldDefinition.new('test real list field', :OFTRealList) }
+  let(:string_field_def) { OGR::FieldDefinition.new('test string field', :OFTString) }
+  let(:string_list_field_def) { OGR::FieldDefinition.new('test string list field', :OFTStringList) }
+  let(:binary_field_def) { OGR::FieldDefinition.new('test binary field', :OFTBinary) }
+  let(:date_field_def) { OGR::FieldDefinition.new('test date field', :OFTDate) }
 
   let(:feature_definition) do
     fd = OGR::FeatureDefinition.new('test FD')
 
-    fd.add_field_definition(integer_field)        # 0
-    fd.add_field_definition(integer_list_field)   # 1
-    fd.add_field_definition(real_field)           # 2
-    fd.add_field_definition(real_list_field)      # 3
-    fd.add_field_definition(string_field)         # 4
-    fd.add_field_definition(string_list_field)    # 5
-    fd.add_field_definition(binary_field)         # 6
-    fd.add_field_definition(date_field)           # 7
+    fd.add_field_definition(integer_field_def)        # 0
+    fd.add_field_definition(integer_list_field_def)   # 1
+    fd.add_field_definition(real_field_def)           # 2
+    fd.add_field_definition(real_list_field_def)      # 3
+    fd.add_field_definition(string_field_def)         # 4
+    fd.add_field_definition(string_list_field_def)    # 5
+    fd.add_field_definition(binary_field_def)         # 6
+    fd.add_field_definition(date_field_def)           # 7
 
-    fd.add_geometry_field_definition(geometry_field_definition)
+    gfd = fd.geometry_field_definition(0)
+    gfd.type = :wkbPoint
+    gfd.name = 'test point'
 
     fd
   end
@@ -218,21 +217,23 @@ RSpec.describe OGR::Feature do
   end
 
   describe '#set_field_raw + #field_as_raw' do
-    let(:integer_field_struct) do
-      f = FFI::OGR::Field.new
-      f[:integer] = 1
+    let(:integer_field) do
+      f = OGR::Field.new
+      f.integer = 1
+
       f
     end
 
-    let(:integer_list_field_struct) do
-      f = FFI::OGR::Field.new
-      f[:integer_list] = [1, 2, 3]
+    let(:integer_list_field) do
+      f = OGR::Field.new
+      f.integer_list = [1, 2, 3]
+
       f
     end
 
     context 'to a valid index' do
       it 'adds the field' do
-        subject.set_field_raw(0, integer_field_struct)
+        subject.set_field_raw(0, integer_field)
         expect(subject.field_as_integer(0)).to eq 1
       end
     end
@@ -240,27 +241,10 @@ RSpec.describe OGR::Feature do
     context 'to an invalid valid index' do
       it 'adds the field' do
         expect do
-          subject.set_field_raw(100, integer_field_struct)
+          subject.set_field_raw(100, integer_field)
         end.to raise_exception GDAL::Error
       end
     end
-
-    context 'raw field is not of the given type' do
-      let(:int_feature_definition) do
-        fd = OGR::FeatureDefinition.new('test FD')
-        fd.add_field_definition(integer_field)        # 0
-
-        fd
-      end
-
-      subject { described_class.new(int_feature_definition) }
-
-      it 'raises a TypeError' do
-        expect do
-          subject.set_field_raw(0, integer_list_field_struct)
-        end.to raise_exception TypeError
-      end
-    end
   end
 
   describe '#set_field_binary + #field_as_binary' do

data/spec/unit/ogr/geometries/geometry_collection_25d_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'ogr'
+
+RSpec.describe OGR::GeometryCollection25D do
+  describe '#type' do
+    context 'when created with data' do
+      subject { OGR::Geometry.create_from_wkt(wkt) }
+      let(:wkt) { 'GEOMETRYCOLLECTION(POINT(4 6 8),LINESTRING(4 6 8,7 10 11))' }
+
+      it 'returns :wkbGeometryCollection25D' do
+        expect(subject.type).to eq :wkbGeometryCollection25D
+      end
+    end
+
+    context 'when created without data' do
+      subject { described_class.new }
+
+      it 'returns :wkbGeometryCollection' do
+        expect(subject.type).to eq :wkbGeometryCollection
+      end
+    end
+  end
+end

data/spec/unit/ogr/geometries/geometry_collection_spec.rb

@@ -64,7 +64,7 @@ RSpec.describe OGR::GeometryCollection do
         end
 
         let(:line_string2) do
-          OGR::Geometry.create_from_wkt('LINESTRING (100 100,100 200,100 300)')
+          OGR::Geometry.create_from_wkt('LINESTRING (100 100,100 20,100 30)')
         end
 
         it 'raises a OGR::Failure error' do
@@ -123,7 +123,7 @@ RSpec.describe OGR::GeometryCollection do
         end
 
         let(:line_string2) do
-          OGR::Geometry.create_from_wkt('LINESTRING (100 100,100 200,0 2)')
+          OGR::Geometry.create_from_wkt('LINESTRING (100 100,100 20,0 2)')
         end
 
         it 'raises a OGR::Failure' do
@@ -178,7 +178,7 @@ RSpec.describe OGR::GeometryCollection do
         it 'raises a GDAL::UnsupportedOperation or OGR::UnsupportedGeometryType' do
           expect do
             subject.polygon_from_edges(100, auto_close: false)
-          end.to raise_exception
+          end.to raise_exception(GDAL::UnsupportedOperation)
         end
       end
     end

data/spec/unit/ogr/geometries/line_string_25d_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'ogr'
+
+RSpec.describe OGR::LineString25D do
+  describe '#type' do
+    context 'when created with data' do
+      subject { OGR::Geometry.create_from_wkt(wkt) }
+      let(:wkt) { 'LINESTRING(1 2 3, 2 2 3)' }
+
+      it 'returns :wkbLineString25D' do
+        expect(subject.type).to eq :wkbLineString25D
+      end
+    end
+
+    context 'when created without data' do
+      subject { described_class.new }
+
+      it 'returns :wkbLineString' do
+        expect(subject.type).to eq :wkbLineString
+      end
+    end
+  end
+end

data/spec/unit/ogr/geometries/line_string_spec.rb

@@ -49,7 +49,7 @@ RSpec.describe OGR::LineString do
 
   describe '#point_count' do
     subject { open_line_string.point_count }
-    it { is_expected.to eq 3  }
+    it { is_expected.to eq 3 }
   end
 
   describe '#intersects?' do
@@ -76,7 +76,7 @@ RSpec.describe OGR::LineString do
     context 'other geometry is a line string' do
       context 'outside the ring' do
         let(:other_geometry) do
-          OGR::Geometry.create_from_wkt('LINESTRING (100 100, 200 200)')
+          OGR::Geometry.create_from_wkt('LINESTRING (100 100, 20 20)')
         end
 
         subject { open_line_string.intersects?(other_geometry) }

data/spec/unit/ogr/geometries/linear_ring_spec.rb

@@ -34,7 +34,7 @@ RSpec.describe OGR::LinearRing do
 
   describe '#point_count' do
     subject { linear_ring.point_count }
-    it { is_expected.to eq 5  }
+    it { is_expected.to eq 5 }
   end
 
   describe '#intersects?' do
@@ -61,7 +61,7 @@ RSpec.describe OGR::LinearRing do
     context 'other geometry is a line string' do
       context 'outside the ring' do
         let(:other_geometry) do
-          OGR::Geometry.create_from_wkt('LINESTRING (100 100, 200 200)')
+          OGR::Geometry.create_from_wkt('LINESTRING (100 100, 20 20)')
         end
 
         subject { linear_ring.intersects?(other_geometry) }