ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/spec/unit/gdal/internal_helpers_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'gdal/internal_helpers'
+require 'ogr/spatial_reference'
+require 'gdal/dataset'
+
+RSpec.describe GDAL::InternalHelpers do
+  subject(:tester) do
+    module Tester
+      include GDAL::InternalHelpers
+    end
+  end
+
+  describe '._pointer' do
+    context 'variable is a kind of the klass that was passed in' do
+      let(:variable) { OGR::SpatialReference.new }
+
+      it "returns the variable's pointer with autorelease = true" do
+        expect(variable.c_pointer).to receive(:autorelease=).with(true)
+        expect(subject._pointer(OGR::SpatialReference, variable)).to eq variable.c_pointer
+      end
+    end
+
+    context 'variable is an FFI::Pointer' do
+      let(:variable) { FFI::MemoryPointer.new(:pointer) }
+
+      it 'returns the pointer with autorelease = true' do
+        expect(variable).to receive(:autorelease=).with(true)
+        expect(subject._pointer(GDAL::Dataset, variable)).to eq variable
+      end
+    end
+
+    context 'variable is nil' do
+      it 'returns nil' do
+        expect(subject._pointer(GDAL::Dataset, nil, false)).to be_nil
+      end
+    end
+  end
+
+  describe '._string_array_to_pointer' do
+    context 'an array' do
+      let(:array) { ['one', 2, 3.0, :four] }
+
+      it 'returns a pointer that contains the array values as strings' do
+        pointer = subject._string_array_to_pointer(array)
+        expect(pointer).to be_an FFI::MemoryPointer
+        expect(pointer.get_array_of_string(0)).to eq %w[one 2 3.0 four]
+      end
+    end
+
+    context 'not an array' do
+      it 'raises an error about no responding to #map' do
+        expect do
+          subject._string_array_to_pointer('blarg')
+        end.to raise_exception NoMethodError
+      end
+    end
+  end
+
+  describe '._gdal_data_type_to_ffi' do
+    context 'data type is :GDT_Byte' do
+      subject { tester._gdal_data_type_to_ffi(:GDT_Byte) }
+      it { is_expected.to eq :uchar }
+    end
+
+    context 'data type is :GDT_UInt16' do
+      subject { tester._gdal_data_type_to_ffi(:GDT_UInt16) }
+      it { is_expected.to eq :uint16 }
+    end
+
+    context 'data type is :GDT_Int16' do
+      subject { tester._gdal_data_type_to_ffi(:GDT_Int16) }
+      it { is_expected.to eq :int16 }
+    end
+
+    context 'data type is :GDT_UInt32' do
+      subject { tester._gdal_data_type_to_ffi(:GDT_UInt32) }
+      it { is_expected.to eq :uint32 }
+    end
+
+    context 'data type is :GDT_Int32' do
+      subject { tester._gdal_data_type_to_ffi(:GDT_Int32) }
+      it { is_expected.to eq :int32 }
+    end
+
+    context 'data type is :GDT_Float32' do
+      subject { tester._gdal_data_type_to_ffi(:GDT_Float32) }
+      it { is_expected.to eq :float }
+    end
+
+    context 'data type is :GDT_Float64' do
+      subject { tester._gdal_data_type_to_ffi(:GDT_Float64) }
+      it { is_expected.to eq :double }
+    end
+
+    context 'data type is not one listed' do
+      subject { tester._gdal_data_type_to_ffi(:blargh) }
+      it { is_expected.to eq :float }
+    end
+  end
+
+  describe '._supported?' do
+    context 'function is supported' do
+      subject { tester._supported?(:GDALAllRegister) }
+      it { is_expected.to eq true }
+    end
+
+    context 'function is not supported' do
+      subject { tester._supported?(:darrells) }
+      it { is_expected.to eq false }
+    end
+  end
+end

data/spec/unit/gdal/major_object_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'gdal/major_object'
+
+RSpec.describe GDAL::MajorObject do
+  subject { Object.new.extend(described_class) }
+end

data/spec/unit/gdal/options_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'gdal/options'
+
+RSpec.describe GDAL::Options do
+end

data/spec/unit/gdal/raster_attribute_table_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'gdal/raster_attribute_table'
+
+RSpec.describe GDAL::RasterAttributeTable do
+end

data/spec/unit/gdal/raster_band_classifier_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'gdal/driver'
+require 'gdal/raster_band_classifier'
+
+RSpec.describe GDAL::RasterBandClassifier do
+  let(:driver) { GDAL::Driver.by_name('MEM') }
+
+  let(:dataset) do
+    driver.create_dataset 'test dataset', 640, 480
+  end
+
+  let(:raster_band) do
+    band = dataset.raster_band 1
+    new_values = band.to_na.indgen!
+    band.write_array(new_values)
+    band
+  end
+
+  subject(:classifier) { described_class.new(raster_band) }
+
+  describe '#add_range' do
+    context 'range param is a Range' do
+      it 'adds the hash to the list of @ranges' do
+        expect do
+          subject.add_range 0..10, 1
+        end.to change { subject.ranges.size }.by 1
+      end
+    end
+
+    context 'range param is not a Range' do
+      it 'raises a RuntimeError' do
+        expect do
+          subject.add_range [1, 2, 3], 1
+        end.to raise_exception RuntimeError
+      end
+    end
+  end
+
+  describe '#add_ranges' do
+    let(:ranges) do
+      [
+        { range: 0..10, map_to: 1000 },
+        { range: 10..100, map_to: 1 }
+      ]
+    end
+
+    it 'adds a list of ranges to @ranges' do
+      expect do
+        subject.add_ranges(ranges)
+      end.to change { subject.ranges.size }.by ranges.size
+    end
+  end
+
+  describe '#equal_count_ranges' do
+    context 'band type is :GDT_Byte' do
+      subject { classifier.equal_count_ranges(4) }
+
+      it 'is an Array of Hashes' do
+        expect(subject).to be_an Array
+        expect(subject.first).to be_a Hash
+      end
+
+      it 'has map_to values that are between 1 and 4' do
+        map_to_values = subject.map { |range| range[:map_to] }.uniq
+        expect(map_to_values).to contain_exactly(1, 2, 3, 4)
+      end
+    end
+
+    context 'band type is :GDT_Float32' do
+      let(:raster_band) do
+        band = float_dataset.raster_band 1
+        new_values = band.to_na.indgen!
+        band.write_array(new_values)
+        band
+      end
+
+      let(:float_dataset) do
+        driver.create_dataset 'test dataset', 640, 480, data_type: :GDT_Float32
+      end
+
+      subject { classifier.equal_count_ranges(4) }
+
+      it 'is an Array of Hashes' do
+        expect(subject).to be_an Array
+        expect(subject.first).to be_a Hash
+      end
+
+      it 'has map_to values that are between 1 and 4' do
+        map_to_values = subject.map { |range| range[:map_to] }.uniq
+        expect(map_to_values).to contain_exactly(1.0, 2.0, 3.0, 4.0)
+      end
+    end
+  end
+
+  describe '#classify!' do
+    before do
+      ranges = subject.equal_count_ranges(10)
+      subject.add_ranges(ranges)
+    end
+
+    context 'no_data_value is set' do
+      before do
+        raster_band.no_data_value = 0
+        subject.classify!
+      end
+
+      it 'has a max value equal to the number of ranges' do
+        min_max = raster_band.min_max
+        expect(min_max[:max]).to eq 10
+      end
+
+      it 'has a min value of 1' do
+        min_max = raster_band.min_max
+        expect(min_max[:min]).to eq 1
+      end
+    end
+
+    context 'no_data_value is not set' do
+      before do
+        subject.classify!
+      end
+
+      it 'has a max value equal to the number of ranges' do
+        min_max = raster_band.min_max
+        expect(min_max[:max]).to eq 10
+      end
+
+      it 'has a min value of 0' do
+        min_max = raster_band.min_max
+        expect(min_max[:min]).to eq 0
+      end
+    end
+  end
+end

data/spec/unit/gdal/raster_band_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'gdal/raster_band'
+
+RSpec.describe GDAL::RasterBand do
+end

data/spec/unit/gdal/rpc_info_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'gdal/rpc_info'
+
+RSpec.describe GDAL::RPCInfo do
+end

data/spec/unit/gdal/version_info_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'gdal/version_info'
+
+RSpec.describe GDAL::VersionInfo do
+  subject { Object.new.extend(described_class) }
+end

data/spec/unit/gdal/virtual_dataset_spec.rb

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'gdal/warp_operation'
+
+RSpec.describe GDAL::WarpOperation do
+end

data/spec/unit/ogr/data_source_mixins/capability_methods_spec.rb

@@ -0,0 +1,30 @@
+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 false }
+    end
+  end
+end

data/spec/unit/ogr/data_source_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+require 'ogr/data_source'
+require 'ogr/spatial_reference'
+
+RSpec.describe OGR::DataSource do
+  describe '.open' do
+    context 'not a data source' do
+      it 'raises an OGR::OpenFailure' do
+        expect do
+          described_class.open('blarg', 'r')
+        end.to raise_exception OGR::OpenFailure
+      end
+    end
+  end
+
+  let(:driver) { OGR::Driver.by_name 'Memory' }
+
+  subject(:data_source) do
+    driver.create_data_source('spec')
+  end
+
+  describe '#name' do
+    subject { data_source.name }
+    it { is_expected.to eq 'spec' }
+  end
+
+  describe '#driver' do
+    subject { data_source.driver.name }
+    it { is_expected.to eq 'Memory' }
+  end
+
+  describe '#layer_count' do
+    subject { data_source.layer_count }
+    it { is_expected.to be_zero }
+  end
+
+  describe '#layer' do
+    context 'no layers' do
+      subject { data_source.layer(0) }
+      it { is_expected.to be_nil }
+    end
+
+    context '1 layer' do
+      before { data_source.create_layer 'unknown layer' }
+      subject { data_source.layer(0) }
+      it { is_expected.to be_a OGR::Layer }
+    end
+  end
+
+  describe '#layer_by_name' do
+    context 'no layers' do
+      subject { data_source.layer_by_name 'meow' }
+      it { is_expected.to be_nil }
+    end
+
+    context '1 layer' do
+      before { data_source.create_layer 'unknown layer' }
+      subject { data_source.layer_by_name 'unknown layer' }
+      it { is_expected.to be_a OGR::Layer }
+    end
+  end
+
+  describe '#create_layer' do
+    context 'cannot create layer' do
+      before do
+        expect(subject).to receive(:can_create_layer?).and_return false
+      end
+
+      it 'raises an OGR::UnsupportedOperation' do
+        expect { subject.create_layer('test') }.to raise_exception OGR::UnsupportedOperation
+      end
+    end
+
+    context 'can create layer' do
+      context 'geometry type is :wkbUnknown' do
+        it 'adds a new OGR::Layer to @layers' do
+          expect do
+            data_source.create_layer('unknown layer')
+          end.to change { data_source.layers.size }.by 1
+        end
+
+        it 'has a layer that is the given geometry type' do
+          layer = data_source.create_layer('unknown layer', geometry_type: :wkbUnknown)
+          expect(layer.geometry_type).to eq :wkbUnknown
+        end
+      end
+
+      context 'geometry type is *not* :wkbUnknown' do
+        it 'adds a new OGR::Layer to @layers' do
+          expect do
+            data_source.create_layer('polygon layer', geometry_type: :wkbPolygon)
+          end.to change { data_source.layers.size }.by 1
+        end
+
+        it 'has a layer that is the given geometry type' do
+          layer = data_source.create_layer('polygon layer', geometry_type: :wkbPolygon)
+          expect(layer.geometry_type).to eq :wkbPolygon
+        end
+      end
+
+      context 'spatial reference is passed in' do
+        let(:spatial_reference) { OGR::SpatialReference.new_from_epsg(4326) }
+
+        it 'adds a new OGR::Layer to @layers' do
+          expect do
+            data_source.create_layer('polygon layer', spatial_reference: spatial_reference)
+          end.to change { data_source.layers.size }.by 1
+        end
+
+        it 'has a layer that uses that spatial reference' do
+          layer = data_source.create_layer('polygon layer', spatial_reference: spatial_reference)
+          expect(layer.spatial_reference.to_wkt).to eq spatial_reference.to_wkt
+        end
+      end
+    end
+  end
+
+  describe '#copy_layer' do
+    let!(:unknown_layer) { subject.create_layer 'unknown layer' }
+
+    it 'adds a new OGR::Layer to @layers' do
+      expect do
+        subject.copy_layer(unknown_layer, 'meow layer')
+      end.to change { subject.layers.size }.by 1
+    end
+
+    it 'makes a copy of the layer' do
+      copied_layer = subject.copy_layer(unknown_layer, 'meow layer')
+      expect(copied_layer.geometry_type).to eq unknown_layer.geometry_type
+    end
+  end
+
+  describe '#delete_layer' do
+    context 'deleting not supported' do
+      before do
+        expect(subject).to receive(:can_delete_layer?).and_return false
+      end
+
+      it 'raises an OGR::UnsupportedOperation' do
+        expect { subject.delete_layer(0) }.to raise_exception OGR::UnsupportedOperation
+      end
+    end
+
+    context 'deleting is supported' do
+      context 'no layers' do
+        it 'raises a OGR::Failure' do
+          expect do
+            data_source.delete_layer(0)
+          end.to raise_exception OGR::Failure
+        end
+      end
+
+      context '1 layer' do
+        before { data_source.create_layer 'unknown layer' }
+        subject { data_source.delete_layer(0) }
+        it { is_expected.to eq true }
+      end
+    end
+  end
+
+  describe '#style_table' do
+    context 'no associated style table' do
+      subject { data_source.style_table }
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#style_table=' do
+    context 'no style table associated' do
+      let(:style_table) do
+        st = OGR::StyleTable.new
+        st.add_style('test', '#123456')
+        st
+      end
+
+      it 'assigns the new style table' do
+        subject.style_table = style_table
+        expect(subject.style_table.find('test')).to eq '#123456'
+      end
+    end
+  end
+
+  describe '#test_capability' do
+    context 'supported capabilities to check' do
+      let(:capabilities) do
+        %w[ODsCCreateLayer ODsCDeleteLayer ODsCCreateGeomFieldAfterCreateLayer ODsCCurveGeometries]
+      end
+
+      # I don't get why these return false...
+      it 'returns false' do
+        capabilities.each do |capability|
+          expect(subject.test_capability(capability)).to eq false
+        end
+      end
+    end
+
+    context 'unsupported capabilities to check' do
+      it 'returns false' do
+        expect(subject.test_capability('meow')).to eq false
+      end
+    end
+  end
+
+  describe '#sync_to_disk' do
+    it 'returns true' do
+      expect(subject.sync_to_disk).to eq true
+    end
+  end
+end

data/spec/unit/ogr/driver_mixins/capability_methods_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'ogr/driver'
+
+RSpec.describe OGR::Driver do
+  context 'Memory driver' do
+    subject(:driver) { OGR::Driver.by_name('Memory') }
+
+    describe '#can_create_data_source?' do
+      subject { driver.can_create_data_source? }
+      it { is_expected.to eq true }
+    end
+
+    describe '#can_delete_data_source?' do
+      subject { driver.can_delete_data_source? }
+      it { is_expected.to eq false }
+    end
+  end
+end