ffi-gdal 1.0.0.beta16 → 1.0.0

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

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/version_info'
-
-RSpec.describe GDAL::VersionInfo do
-  subject { Object.new.extend(described_class) }
-
-  pending 'Add some tests!'
-end

data/spec/unit/gdal/virtual_dataset_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/virtual_dataset'
-require 'gdal/dataset'
-
-RSpec.describe GDAL::VirtualDataset do
-  subject(:virtual_dataset) { described_class.new(300, 200) }
-
-  describe '#initialize' do
-    it { is_expected.to be_a GDAL::VirtualDataset }
-  end
-
-  describe '#flush_cache' do
-    it 'does something' do
-      subject.flush_cache
-    end
-  end
-
-  describe '#to_xml' do
-    it 'returns a String' do
-      expect(subject.to_xml).to be_a String
-      expect(subject.to_xml.size).to be > 0
-    end
-  end
-
-  describe '#add_band' do
-    context 'valid data type' do
-      it "lets you add a real dataset's raster band to it" do
-        expect(subject.add_band(:GDT_Byte)).to eq 0
-      end
-    end
-  end
-end

data/spec/unit/gdal/warp_operation_spec.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/warp_operation'
-
-RSpec.describe GDAL::WarpOperation do
-  pending 'Add some tests!'
-end

data/spec/unit/gdal/warp_options_spec.rb

@@ -1,338 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/warp_options'
-
-RSpec.describe GDAL::WarpOptions do
-  shared_examples 'a WarpOptions object' do
-    it 'inits proper types' do
-      expect(subject.warp_operation_options).to be_a Hash
-
-      expect(subject.source_bands).to be_a Array
-      expect(subject.destination_bands).to be_a Array
-
-      expect(subject.source_no_data_real).to be_a Array
-      expect(subject.source_no_data_imaginary).to be_a Array
-      expect(subject.destination_no_data_real).to be_a Array
-      expect(subject.destination_no_data_imaginary).to be_a Array
-
-      expect(subject.progress).to be_a FFI::Function
-      expect(subject.progress_arg).to be_a FFI::Pointer
-      expect(subject.transformer).to be_a FFI::Function
-      expect(subject.transformer_arg).to be_a FFI::Pointer
-
-      expect(subject.source_per_band_validity_mask_function).to be_a FFI::Pointer
-      expect(subject.source_per_band_validity_mask_function_arg).to be_a FFI::Pointer
-      expect(subject.source_validity_mask_function).to be_a FFI::Function
-      expect(subject.source_validity_mask_function_arg).to be_a FFI::Pointer
-      expect(subject.source_density_mask_function).to be_a FFI::Function
-      expect(subject.source_density_mask_function_arg).to be_a FFI::Pointer
-
-      expect(subject.destination_density_mask_function).to be_a FFI::Function
-      expect(subject.destination_density_mask_function_arg).to be_a FFI::Pointer
-      expect(subject.destination_validity_mask_function).to be_a FFI::Function
-      expect(subject.destination_validity_mask_function_arg).to be_a FFI::Pointer
-
-      expect(subject.pre_warp_chunk_processor).to be_a FFI::Function
-      expect(subject.pre_warp_processor_arg).to be_a FFI::Pointer
-      expect(subject.post_warp_chunk_processor).to be_a FFI::Function
-      expect(subject.post_warp_processor_arg).to be_a FFI::Pointer
-    end
-  end
-
-  describe '#initialize' do
-    context 'with no options' do
-      it_behaves_like 'a WarpOptions object'
-
-      it 'inits a FFI::GDAL::WarpOptions struct internally, with nothing set' do
-        expect(subject.warp_operation_options).to eq({})
-
-        expect(subject.warp_memory_limit).to be_zero
-        expect(subject.resample_alg).to eq(:GRA_NearestNeighbor) # 0 enum
-        expect(subject.working_data_type).to eq(:GDT_Unknown) # 0 enum
-
-        expect(subject.source_dataset).to be_nil
-        expect(subject.destination_dataset).to be_nil
-
-        expect(subject.band_count).to be_zero
-        expect(subject.source_bands).to be_empty
-        expect(subject.destination_bands).to be_empty
-
-        expect(subject.source_alpha_band).to be_zero
-        expect(subject.destination_alpha_band).to be_zero
-
-        expect(subject.source_no_data_real).to eq([])
-        expect(subject.source_no_data_imaginary).to eq([])
-        expect(subject.destination_no_data_real).to eq([])
-        expect(subject.destination_no_data_imaginary).to eq([])
-
-        expect(subject.progress).to_not be_null
-        expect(subject.progress_arg).to be_null
-
-        expect(subject.transformer).to be_null
-        expect(subject.transformer_arg).to be_null
-
-        expect(subject.source_per_band_validity_mask_function).to be_null
-        expect(subject.source_per_band_validity_mask_function_arg).to be_null
-
-        expect(subject.source_validity_mask_function).to be_null
-        expect(subject.source_validity_mask_function_arg).to be_null
-
-        expect(subject.source_density_mask_function).to be_null
-        expect(subject.source_density_mask_function_arg).to be_null
-
-        expect(subject.destination_density_mask_function).to be_null
-        expect(subject.destination_density_mask_function_arg).to be_null
-
-        expect(subject.destination_validity_mask_function).to be_null
-        expect(subject.destination_validity_mask_function_arg).to be_null
-
-        expect(subject.pre_warp_chunk_processor).to be_null
-        expect(subject.pre_warp_processor_arg).to be_null
-        expect(subject.post_warp_chunk_processor).to be_null
-        expect(subject.post_warp_processor_arg).to be_null
-
-        expect(subject.cutline).to be_nil
-        expect(subject.cutline_blend_distance).to eq(0.0)
-      end
-    end
-
-    context 'passing in options that are also accessor methods' do
-      let(:warp_operation_options) do
-        {
-          init_dest: 'NODATA',
-          write_flush: 'YES',
-          skip_nosource: 'NO',
-          sample_grid: 'YES'
-        }
-      end
-
-      let(:memory_driver) { GDAL::Driver.by_name('MEM') }
-      let(:source_dataset) { memory_driver.create_dataset 'source', 10, 20 }
-      let(:dest_dataset) { memory_driver.create_dataset 'dest', 20, 30 }
-      let(:cutline) { OGR::LineString.new }
-      let(:spb_validity_mask_function1) { proc { true } }
-      let(:spb_validity_mask_function2) { proc { false } }
-
-      after do
-        source_dataset.close
-        dest_dataset.close
-      end
-
-      subject do
-        described_class.new warp_operation_options: warp_operation_options,
-                            source_dataset: source_dataset,
-                            destination_dataset: dest_dataset,
-                            source_bands: [1, 2, 3],
-                            destination_bands: [2, 4, 6],
-                            cutline: cutline,
-                            source_no_data_real: [123.456, 78.9, -999.9],
-                            source_no_data_imaginary: [1.2, 3.4, -5.6],
-                            destination_no_data_real: [11.1, 22.2, 33.3],
-                            destination_no_data_imaginary: [-44.4, -55.5, -66.6],
-                            source_per_band_validity_mask_function: [
-                              spb_validity_mask_function1,
-                              spb_validity_mask_function2
-                            ]
-      end
-
-      it_behaves_like 'a WarpOptions object'
-
-      it 'sets warp_operation_options' do
-        expect(subject.warp_operation_options).to eq(warp_operation_options)
-      end
-
-      it' sets source_dataset and the internal pointer' do
-        expect(subject.source_dataset).to eq(source_dataset)
-        expect(subject.c_struct[:source_dataset]).to eq(source_dataset.c_pointer)
-      end
-
-      it' sets destination_dataset' do
-        expect(subject.destination_dataset).to eq(dest_dataset)
-        expect(subject.c_struct[:destination_dataset]).to eq(dest_dataset.c_pointer)
-      end
-
-      it 'sets source_bands' do
-        expect(subject.source_bands).to eq([1, 2, 3])
-      end
-
-      it 'sets destination_bands' do
-        expect(subject.destination_bands).to eq([2, 4, 6])
-      end
-
-      it 'sets band_count and the internal to 3' do
-        expect(subject.band_count).to eq 3
-        expect(subject.c_struct[:band_count]).to eq 3
-      end
-
-      it 'sets cutline and its internal pointer' do
-        expect(subject.cutline).to eq(cutline)
-        expect(subject.c_struct[:cutline]).to eq(cutline.c_pointer)
-      end
-
-      it 'sets source_no_data_real' do
-        expect(subject.source_no_data_real).to eq([123.456, 78.9, -999.9])
-      end
-
-      it 'sets source_no_data_imaginary' do
-        expect(subject.source_no_data_imaginary).to eq([1.2, 3.4, -5.6])
-      end
-
-      it 'sets destination_no_data_real' do
-        expect(subject.destination_no_data_real).to eq([11.1, 22.2, 33.3])
-      end
-
-      it 'sets destination_no_data_imaginary' do
-        expect(subject.destination_no_data_imaginary).to eq([-44.4, -55.5, -66.6])
-      end
-
-      it 'sets source_per_band_validity_mask_function' do
-        function_ptr = subject.source_per_band_validity_mask_function
-        expect(function_ptr).to be_a(FFI::Pointer)
-
-        function = function_ptr.read_pointer
-        expect(function).to_not be_null
-      end
-    end
-
-    context 'passing in options that are NOT accessor methods' do
-      def make_int_pointer(int)
-        i = FFI::MemoryPointer.new(:int)
-        i.write_int(int)
-        i
-      end
-
-      let(:progress) { proc { true } }
-      let(:test_mask_function) { proc { true } }
-
-      let(:source_per_band_validity_mask_function_arg) { make_int_pointer(5) }
-      let(:source_validity_mask_function_arg) { make_int_pointer(3) }
-      let(:source_density_mask_function_arg) { make_int_pointer(2) }
-      let(:destination_validity_mask_function_arg) { make_int_pointer(4) }
-      let(:destination_density_mask_function_arg) { make_int_pointer(11) }
-      let(:pre_warp_processor_arg) { make_int_pointer(7) }
-      let(:post_warp_processor_arg) { make_int_pointer(9) }
-
-      subject do
-        described_class.new warp_memory_limit: 123,
-                            resample_alg: :GRA_Lanczos,
-                            working_data_type: :GDT_CInt32,
-                            band_count: 3,
-                            source_alpha_band: 1,
-                            destination_alpha_band: 5,
-                            progress: progress,
-                            progress_arg: FFI::CPL::Progress::ScaledProgress,
-                            source_per_band_validity_mask_function_arg: source_per_band_validity_mask_function_arg,
-                            source_validity_mask_function: test_mask_function,
-                            source_validity_mask_function_arg: source_validity_mask_function_arg,
-                            source_density_mask_function: test_mask_function,
-                            source_density_mask_function_arg: source_density_mask_function_arg,
-                            destination_validity_mask_function: test_mask_function,
-                            destination_validity_mask_function_arg: destination_validity_mask_function_arg,
-                            destination_density_mask_function: test_mask_function,
-                            destination_density_mask_function_arg: destination_density_mask_function_arg,
-                            pre_warp_chunk_processor: proc { :CE_Warning },
-                            pre_warp_processor_arg: pre_warp_processor_arg,
-                            post_warp_chunk_processor: proc { :CE_Failure },
-                            post_warp_processor_arg: post_warp_processor_arg,
-                            cutline_blend_distance: 3.3
-      end
-
-      it_behaves_like 'a WarpOptions object'
-
-      it 'sets warp_memory_limit' do
-        expect(subject.warp_memory_limit).to eq(123)
-      end
-
-      it 'sets resample_alg' do
-        expect(subject.resample_alg).to eq(:GRA_Lanczos)
-      end
-
-      it 'sets working_data_type' do
-        expect(subject.working_data_type).to eq(:GDT_CInt32)
-      end
-
-      it 'sets band_count' do
-        expect(subject.band_count).to eq(3)
-      end
-
-      it 'sets source_alpha_band' do
-        expect(subject.source_alpha_band).to eq(1)
-      end
-
-      it 'sets destination_alpha_band' do
-        expect(subject.destination_alpha_band).to eq(5)
-      end
-
-      it 'sets progress_arg' do
-        expect(subject.progress_arg).to eq(FFI::CPL::Progress::ScaledProgress)
-      end
-
-      it 'sets source_per_band_validity_mask_function_arg' do
-        pointer = subject.source_per_band_validity_mask_function_arg
-        pointer.autorelease = false
-        expect(pointer.read_int).to eq 5
-      end
-
-      it 'sets source_validity_mask_function' do
-        expect(subject.source_validity_mask_function).to_not be_null
-      end
-
-      it 'sets source_validity_mask_function_arg' do
-        pointer = subject.source_validity_mask_function_arg
-        pointer.autorelease = false
-        expect(pointer.read_int).to eq 3
-      end
-
-      it 'sets source_density_mask_function' do
-        expect(subject.source_density_mask_function).to_not be_null
-      end
-
-      it 'sets source_density_mask_function_arg' do
-        pointer = subject.source_density_mask_function_arg
-        pointer.autorelease = false
-        expect(pointer.read_int).to eq 2
-      end
-
-      it 'sets destination_validity_mask_function' do
-        expect(subject.destination_validity_mask_function).to_not be_null
-      end
-
-      it 'sets destination_validity_mask_function_arg' do
-        pointer = subject.destination_validity_mask_function_arg
-        pointer.autorelease = false
-        expect(pointer.read_int).to eq 4
-      end
-
-      it 'sets destination_density_mask_function' do
-        expect(subject.destination_density_mask_function).to_not be_null
-      end
-
-      it 'sets destination_density_mask_function_arg' do
-        pointer = subject.destination_density_mask_function_arg
-        pointer.autorelease = false
-        expect(pointer.read_int).to eq 11
-      end
-
-      it 'sets pre_warp_chunk_processor' do
-        expect(subject.pre_warp_chunk_processor.call(nil, nil)).to eq(:CE_Warning)
-      end
-
-      it 'sets pre_warp_chunk_processor_arg' do
-        expect(subject.pre_warp_processor_arg).to_not be_null
-      end
-
-      it 'sets post_warp_chunk_processor' do
-        expect(subject.post_warp_chunk_processor.call(nil, nil)).to eq(:CE_Failure)
-      end
-
-      it 'sets post_warp_chunk_processor_arg' do
-        expect(subject.post_warp_processor_arg).to_not be_null
-      end
-
-      it 'sets cutline_blend_distance' do
-        expect(subject.cutline_blend_distance).to eq(3.3)
-      end
-    end
-  end
-end

data/spec/unit/ogr/coordinate_transformation_spec.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-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_mixins/capability_methods_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'ogr/data_source'
-
-RSpec.describe OGR::DataSource do
-  context 'Memory datasource' do
-    subject(:data_source) do
-      OGR::Driver.by_name('Memory').create_data_source('test')
-    end
-
-    describe '#can_create_layer?' do
-      subject { data_source.can_create_layer? }
-      it { is_expected.to eq true }
-    end
-
-    describe '#can_delete_layer?' do
-      subject { data_source.can_delete_layer? }
-      it { is_expected.to eq true }
-    end
-
-    describe '#can_create_geometry_field_after_create_layer?' do
-      subject { data_source.can_create_geometry_field_after_create_layer? }
-      it { is_expected.to eq true }
-    end
-
-    describe '#supports_curve_geometries?' do
-      subject { data_source.supports_curve_geometries? }
-      it { is_expected.to eq true }
-    end
-  end
-end