shapelib 0.7.0 → 0.8.0

data/test/test_zillow_data.rb

@@ -0,0 +1,2233 @@
+require 'shapelib'
+require 'test/unit'
+require 'tmpdir'
+require 'fileutils'
+require 'open3'
+require 'rbconfig'
+
+class TestZillowData < Test::Unit::TestCase
+  def test_open_rejects_missing_or_corrupt_geometry
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      fixture = 'test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA'
+      FileUtils.cp("#{fixture}.shp", File.join(dir, 'no_index.shp'))
+      File.binwrite(File.join(dir, 'corrupt.shp'), 'not a shapefile')
+      FileUtils.cp("#{fixture}.shx", File.join(dir, 'corrupt.shx'))
+      %w[missing no_index corrupt].each do |name|
+        filename = File.join(dir, name)
+        assert_file_operation_failure('SHPOpen', filename) do |block|
+          Shapelib::ShapeFile.open(filename, &block)
+        end
+      end
+    end
+  end
+
+  def test_creation_rejects_nonexistent_parent
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'absent', 'points')
+      assert_file_operation_failure('SHPCreate', filename) do |block|
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, &block)
+      end
+      assert_empty Dir.children(dir)
+    end
+  end
+
+  def test_creation_rejects_partial_failure_without_deleting_files
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      Dir.mkdir("#{filename}.dbf")
+      assert_file_operation_failure('DBFCreate', filename) do |block|
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, &block)
+      end
+      assert_path_exist "#{filename}.shp"
+      assert_path_exist "#{filename}.shx"
+      assert_true File.directory?("#{filename}.dbf")
+    end
+  end
+
+  def test_file_creation_and_open_round_trip
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, [['name', Shapelib::String, 10]]) do |file|
+        assert_equal 0, file.write(Shapelib::Point.new(1, 2, { 'name' => 'example' }))
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal 1, file.size
+        assert_equal 1, file.field_count
+        shape = file.read(0)
+        assert_equal [1.0], shape.xvals
+        assert_equal [2.0], shape.yvals
+        assert_equal 'example', shape['name']
+      end
+    end
+  end
+
+  def test_invalid_write_indexes_do_not_modify_files
+    [0, 2].each do |count|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, [['name', Shapelib::String, 10]]) do |file|
+          count.times { |i| file.write(Shapelib::Point.new(i, i, 'name' => "before#{i}")) }
+        end
+        expected = nil
+        Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+          expected = count.times.map { |i| file.read(i).to_h }
+          point = Shapelib::Point.new(9, 9, 'name' => 'after')
+          [-2, count, count + 10].each do |index|
+            error = assert_raise(ArgumentError) { file.write(point, index) }
+            assert_match(/write index #{index} /, error.message)
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |i| file.read(i).to_h }
+          end
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal count, file.size
+          assert_equal expected, count.times.map { |i| file.read(i).to_h }
+        end
+      end
+    end
+  end
+
+  def test_write_indexes_use_current_count_after_appends
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, [['name', Shapelib::String, 10]]) do |file|
+        assert_equal 0, file.size
+        assert_equal 0, file.write(Shapelib::Point.new(1, 2, 'name' => 'first'))
+        assert_equal 1, file.write(Shapelib::Point.new(3, 4, 'name' => 'second'), -1)
+        [0, 1].each do |index|
+          assert_equal index, file.write(Shapelib::Point.new(9, 8, 'name' => 'after'), index)
+        end
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal 2, file.size
+        2.times do |index|
+          point = file.read(index)
+          assert_equal [9.0], point.xvals
+          assert_equal [8.0], point.yvals
+          assert_equal 'after', point['name']
+        end
+      end
+    end
+  end
+
+  def test_write_append_index_forms_round_trip
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      points = 3.times.map { |index| Shapelib::Point.new(index, -index, 'name' => "point#{index}") }
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, [['name', Shapelib::String, 10]]) do |file|
+        assert_equal 0, file.write(points[0])
+        assert_equal 1, file.write(points[1], nil)
+        assert_equal 2, file.write(points[2], -1)
+        assert_equal points.length, file.size
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal points.length, file.size
+        points.each_with_index do |point, index|
+          assert_equal point.to_h.merge(shape_id: index), file.read(index).to_h
+        end
+      end
+    end
+  end
+
+  def test_indexed_read_preserves_following_sequential_position
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      Shapelib::ShapeFile.new(filename, Shapelib::Point) do |file|
+        3.times { |i| file.write(Shapelib::Point.new(i, i)) }
+      end
+      [false, true].each do |size_first|
+        Shapelib::ShapeFile.open(filename) do |file|
+          file.size if size_first
+          assert_equal [1.0], file.read(1).xvals
+          assert_equal [2.0], file.read.xvals
+          file.rewind
+          assert_equal [0.0], file.read.xvals
+        end
+      end
+      Shapelib::ShapeFile.open(filename) { |file| assert_equal [0.0], file.read.xvals }
+    end
+  end
+
+  def test_date_field_types_and_string_values_round_trip
+    omit 'native shapelib has no FTDate' unless Shapelib.const_defined?(:Date, false)
+    [Shapelib::Date, :Date, 'Date'].each do |type|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'dates')
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, [['date', type, 8]]) do |file|
+          assert_equal :Date, file.field_type('date')
+          assert_equal ':Date', file.field_type(0).inspect
+          assert_equal 8, file.field_width(0)
+          assert_equal 0, file.field_decimals(0)
+          ['20261019', '00010102', nil].each do |value|
+            file.write(Shapelib::Point.new(1, 2, { 'date' => value }))
+          end
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal :Date, file.field_type(0)
+          ['20261019', '00010102', nil].each_with_index do |value, index|
+            shape = file.read(index)
+            assert_equal value, shape['date']
+            assert_equal value, shape.to_h['date']
+          end
+        end
+      end
+    end
+  end
+
+  def test_existing_dbf_date_fields_preserve_string_access
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'dates')
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, [['date', Shapelib::String, 8]]) do |file|
+        ['20261019', '00010102', '00000000'].each do |value|
+          file.write(Shapelib::Point.new(1, 2, { 'date' => value }))
+        end
+      end
+      # Use a native DBF date descriptor independently of the gem's Date support.
+      File.open("#{filename}.dbf", 'r+b') { |file| file.seek(32 + 11); file.write('D') }
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal Shapelib.const_defined?(:Date, false) ? :Date : :String, file.field_type('date')
+        ['20261019', '00010102', nil].each_with_index do |value, index|
+          shape = file.read(index)
+          assert_equal value, shape['date']
+          assert_equal value, shape.to_h['date']
+        end
+      end
+    end
+  end
+
+  def test_invalid_field_names_do_not_change_schema
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'fields')
+      fields = [['name', :String, 10, 0], ['amount', :Float, 12, 2]]
+      metadata = lambda do |file|
+        file.fields.map { |name| [name.b, file.field_type(name), file.field_width(name), file.field_decimals(name)] }
+      end
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+        ['abcdefghijk', 'é' * 6, 'name', 'NAME'].each do |name|
+          error = assert_raise(ArgumentError) { file.add_field(name, :Integer, 8) }
+          expected = name.bytesize > 10 ? 'field name exceeds 10 bytes' : "field name already exists: #{name}"
+          assert_equal expected, error.message
+          assert_equal fields.length, file.field_count
+          assert_equal fields, metadata.call(file)
+        end
+        file.add_field('abcdefghij', :String, 10)
+        file.add_field('é' * 5, :String, 10)
+        fields += [['abcdefghij', :String, 10, 0], [('é' * 5).b, :String, 10, 0]]
+        assert_equal fields, metadata.call(file)
+        point = Shapelib::Point.new(1, 2, 'name' => 'before', 'amount' => 1.25,
+                                   'abcdefghij' => 'ten bytes', 'é' * 5 => 'multibyte')
+        assert_equal 0, file.write(point)
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal fields.length, file.field_count
+        assert_equal fields, metadata.call(file)
+        point = file.read(0)
+        assert_equal 'before', point['name']
+        assert_equal 1.25, point['amount']
+        assert_equal 'ten bytes', point['abcdefghij']
+        assert_equal 'multibyte', point['é' * 5]
+      end
+    end
+  end
+
+  def test_constructor_rejects_invalid_field_names
+    ['abcdefghijk', 'é' * 6, 'name', 'NAME'].each do |name|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        fields = [['name', :String, 10], [name, :Integer, 8]]
+        yielded = false
+        error = assert_raise(ArgumentError) do
+          Shapelib::ShapeFile.new(File.join(dir, 'fields'), Shapelib::Point, fields) { yielded = true }
+        end
+        expected = name.bytesize > 10 ? 'field name exceeds 10 bytes' : "field name already exists: #{name}"
+        assert_equal expected, error.message
+        assert_equal false, yielded
+      end
+    end
+  end
+
+  def test_numeric_fields_reject_invalid_precision_without_changing_schema
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'numbers')
+      fields = [['name', :String, 10, 0], ['amount', :Float, 12, 2]]
+      metadata = lambda do |file|
+        file.fields.map { |name| [name, file.field_type(name), file.field_width(name), file.field_decimals(name)] }
+      end
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+        [:Integer, :Float].each do |type|
+          [-1, 256].each do |precision|
+            error = assert_raise(ArgumentError) { file.add_field('bad', type, 12, precision) }
+            assert_equal 'numeric field precision must be between 0 and 255', error.message
+            assert_equal fields.length, file.field_count
+            assert_equal fields, metadata.call(file)
+          end
+        end
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal fields.length, file.field_count
+        assert_equal fields, metadata.call(file)
+      end
+    end
+  end
+
+  def test_constructor_rejects_invalid_numeric_precision
+    [:Integer, :Float].each do |type|
+      [-1, 256].each do |precision|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          fields = [['bad', type, 12, precision]]
+          error = assert_raise(ArgumentError) do
+            Shapelib::ShapeFile.new(File.join(dir, 'numbers'), Shapelib::Point, fields)
+          end
+          assert_equal 'numeric field precision must be between 0 and 255', error.message
+        end
+      end
+    end
+  end
+
+  def test_numeric_precision_boundaries_persist
+    [:Integer, :Float].each do |type|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'numbers')
+        precisions = [0, 2, 255]
+        Shapelib::ShapeFile.new(filename, Shapelib::Point) do |file|
+          precisions.each do |precision|
+            name = "field#{precision}"
+            file.add_field(name, type, 255, precision)
+            assert_equal precision, file.field_decimals(name)
+          end
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal precisions.length, file.field_count
+          precisions.each { |precision| assert_equal precision, file.field_decimals("field#{precision}") }
+        end
+      end
+    end
+  end
+
+  def test_date_fields_require_fixed_width_and_zero_decimals
+    omit 'native shapelib has no FTDate' unless Shapelib.const_defined?(:Date, false)
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      Shapelib::ShapeFile.new(File.join(dir, 'dates'), Shapelib::Point) do |file|
+        [[0, 0], [7, 0], [9, 0], [8, 1]].each do |width, decimals|
+          error = assert_raise(ArgumentError) { file.add_field('date', :Date, width, decimals) }
+          assert_equal 'Date fields require width 8 and zero decimal places', error.message
+          assert_equal 0, file.field_count
+        end
+      end
+    end
+  end
+
+  def test_invalid_date_writes_do_not_modify_files
+    omit 'native shapelib has no FTDate' unless Shapelib.const_defined?(:Date, false)
+    [7, 1.5, '', '2026101', '202610199', '2026x019', '2026-10-19'].each do |value|
+      [[0, -1], [1, -1], [1, 0]].each do |count, index|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'dates')
+          fields = [['name', Shapelib::String, 10], ['date', :Date, 8]]
+          Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+            count.times { file.write(Shapelib::Point.new(1, 2, { 'name' => 'before', 'date' => '20261019' })) }
+          end
+          expected = nil
+          Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+            expected = count.times.map { |record| file.read(record).to_h }
+            shape = Shapelib::Point.new(9, 9, { 'name' => 'after', 'date' => value })
+            assert_raise(value.is_a?(String) ? ArgumentError : TypeError) { file.write(shape, index) }
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+          end
+        end
+      end
+    end
+  end
+
+  def test_date_attributes_can_be_copied_and_replaced
+    omit 'native shapelib has no FTDate' unless Shapelib.const_defined?(:Date, false)
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'dates')
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, [['date', :Date, 8]]) do |file|
+        file.write(Shapelib::Point.new(1, 2, { 'date' => '20261019' }))
+      end
+      Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+        shape = file.read(0)
+        [:Date, :String].each do |type|
+          copy = File.join(dir, type.to_s)
+          Shapelib::ShapeFile.new(copy, Shapelib::Point, [['date', type, 8]]) { |target| target.write(shape) }
+          Shapelib::ShapeFile.open(copy) { |target| assert_equal '20261019', target.read(0)['date'] }
+        end
+        ['00010102', nil].each do |value|
+          shape['date'] = value
+          assert_equal value, shape['date']
+          assert_equal value, shape.to_h['date']
+          file.write(shape, 0)
+          assert_equal value, file.read(0)['date']
+        end
+      end
+      Shapelib::ShapeFile.open(filename) { |file| assert_nil file.read(0)['date'] }
+    end
+  end
+
+  def test_undefined_attributes_do_not_modify_files
+    [[0, -1], [1, -1], [1, 0]].each do |count, index|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        fields = [['name', Shapelib::String, 10], ['other', Shapelib::Integer, 8]]
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+          count.times { file.write(Shapelib::Point.new(1, 2, { 'name' => 'before', 'other' => 7 })) }
+        end
+        expected = nil
+        Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+          expected = count.times.map { |record| file.read(record).to_h }
+          shape = Shapelib::Point.new(9, 9, { 'name' => 'after', 'missing' => 'bad' })
+          error = assert_raise(ArgumentError) { file.write(shape, index) }
+          assert_equal 'attribute missing not defined in ShapeFile', error.message
+          assert_equal count, file.size
+          assert_equal expected, count.times.map { |record| file.read(record).to_h }
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal count, file.size
+          assert_equal expected, count.times.map { |record| file.read(record).to_h }
+        end
+      end
+    end
+  end
+
+  def test_over_width_string_writes_do_not_modify_files
+    ['toolong', 'éé'].each do |value|
+      [[0, -1], [1, -1], [1, 0]].each do |count, index|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'points')
+          fields = [['name', Shapelib::String, 10], ['short', Shapelib::String, 3]]
+          Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+            count.times { file.write(Shapelib::Point.new(1, 2, { 'name' => 'before', 'short' => 'old' })) }
+          end
+          expected = nil
+          Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+            expected = count.times.map { |record| file.read(record).to_h }
+            shape = Shapelib::Point.new(9, 9, { 'name' => 'after', 'short' => value })
+            error = assert_raise(RuntimeError) { file.write(shape, index) }
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            assert_equal 'attribute short exceeds field width', error.message
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+          end
+        end
+      end
+    end
+  end
+
+  def test_over_width_numeric_writes_do_not_modify_files
+    cases = [[:Integer, 3, 0, 12345], [:Integer, 3, 0, -100],
+             [:Integer, 3, 0, 999.6], [:Integer, 3, 0, -99.6],
+             [:Float, 5, 2, 99.999], [:Float, 5, 2, -9.999],
+             [:Float, 5, 2, 100], [:Float, 255, 0, Float::MAX]]
+    cases.each do |type, width, decimals, value|
+      [[0, -1], [1, -1], [1, 0]].each do |count, index|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'points')
+          fields = [['name', Shapelib::String, 10], ['number', type, width, decimals]]
+          Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+            count.times { file.write(Shapelib::Point.new(1, 2, 'name' => 'before', 'number' => 1)) }
+          end
+          expected = nil
+          Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+            expected = count.times.map { |record| file.read(record).to_h }
+            shape = Shapelib::Point.new(9, 9, 'name' => 'after', 'number' => value)
+            error = assert_raise(RuntimeError) { file.write(shape, index) }
+            assert_equal 'attribute number exceeds field width', error.message
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+          end
+        end
+      end
+    end
+  end
+
+  def test_numeric_width_boundaries_preserve_valid_writes
+    cases = [[:Integer, 3, 0, [999, -99, 999.4, -99.4, 12.6, 998.5, -98.5, nil],
+              [999, -99, 999, -99, 13, 998, -98, nil]],
+             [:Float, 5, 2, [99.99, -9.99, 99.994, -9.994, 12, 0, 2.125, nil],
+              [99.99, -9.99, 99.99, -9.99, 12.0, 0.0, 2.12, nil]],
+             [:Float, 255, 0, [1e200, -1e200, nil], [1e200, -1e200, nil]]]
+    cases.each do |type, width, decimals, values, expected|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, [['number', type, width, decimals]]) do |file|
+          values.each_with_index do |value, index|
+            assert_equal index, file.write(Shapelib::Point.new(1, 2, 'number' => value))
+          end
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal values.length, file.size
+          assert_equal expected, values.each_index.map { |index| file.read(index)['number'] }
+        end
+      end
+    end
+  end
+
+  def test_string_width_boundaries_preserve_valid_writes
+    values = ['a', 'abc', '', 'é', 'éa', nil]
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      fields = [['short', Shapelib::String, 3], ['flag', Shapelib::Logical, 1]]
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+        values.each_with_index do |value, index|
+          assert_equal index, file.write(Shapelib::Point.new(1, 2, { 'short' => value, 'flag' => 'True' }))
+        end
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal values.length, file.size
+        values.each_with_index do |value, index|
+          shape = file.read(index)
+          expected = value.nil? || value.empty? ? nil : value.b
+          assert_equal expected, shape['short']
+          assert_equal 'T', shape['flag']
+        end
+      end
+    end
+  end
+
+  def test_invalid_geometry_writes_do_not_modify_files
+    points = [Shapelib::Point.new(1, 2), Shapelib::PointM.new(1, 2, 3), Shapelib::PointZ.new(1, 2, 3, 4)]
+    arc = Shapelib::Arc.new([1, 2], [3, 4])
+    cases = points.permutation(2).to_a + [[points.first, arc], [arc, points.first]]
+    cases.map! do |before, invalid|
+      [before, invalid, /shape type \d+ does not match ShapeFile type \d+/]
+    end
+    points.each do |point|
+      cases << [point, Shapelib::Shape.new(empty_geometry(point.shape_type)), /point has no vertices/]
+      data = point.to_h.merge(n_vertices: 2, xvals: [9, 10], yvals: [11, 12],
+                             zvals: [13, 14], mvals: [15, 16])
+      cases << [point, Shapelib::Shape.new(data), /point must have exactly one vertex \(got 2\)/]
+    end
+    [1, 2].each do |count|
+      data = empty_geometry(:Null).merge(n_vertices: count, xvals: Array.new(count, 9),
+                                         yvals: Array.new(count, 10), zvals: Array.new(count, 11),
+                                         mvals: Array.new(count, 12))
+      (points + [arc]).each do |before|
+        cases << [before, Shapelib::Shape.new(data), /null shape must have no vertices \(got #{count}\)/]
+      end
+    end
+    cases.each do |before, invalid, message|
+      before['name'] = 'before'
+      invalid['name'] = 'after'
+      [[0, -1], [1, -1], [1, 0]].each do |count, index|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'shapes')
+          Shapelib::ShapeFile.new(filename, before.shape_type, [['name', Shapelib::String, 10]]) do |file|
+            count.times { file.write(before) }
+          end
+          expected = nil
+          expected_bounds = nil
+          Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+            expected = count.times.map { |record| file.read(record).to_h }
+            expected_bounds = [file.minbound, file.maxbound]
+            error = assert_raise(ArgumentError) { file.write(invalid, index) }
+            assert_match message, error.message
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            assert_equal expected_bounds, [file.minbound, file.maxbound]
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            assert_equal expected_bounds, [file.minbound, file.maxbound]
+          end
+        end
+      end
+    end
+  end
+
+  def test_unsupported_types_read_from_files_cannot_be_written
+    script = <<~'RUBY'
+      Process.setrlimit(Process::RLIMIT_CORE, 0, 0) if Process.const_defined?(:RLIMIT_CORE)
+      require 'shapelib'
+      filename, type, index = ARGV
+      Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+        shape = file.read(0)
+        abort 'unexpected fixture type' unless file.shape_type == type.to_i && shape.shape_type == type.to_i
+        begin
+          file.write(shape, index.to_i)
+        rescue ArgumentError => error
+          abort error.message unless error.message == "unsupported shape type #{type}"
+        else
+          abort 'unsupported write succeeded'
+        end
+      end
+    RUBY
+    [2, 99].product([-1, 0]).each do |type, index|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'shapes')
+        Shapelib::ShapeFile.new(filename, :Point, [['name', :String, 10]]) do |file|
+          file.write(Shapelib::Point.new(1, 2, 'name' => 'before'))
+        end
+        paths = %w[shp shx dbf].map { |extension| "#{filename}.#{extension}" }
+        paths.first(2).each do |path|
+          bytes = File.binread(path)
+          bytes[32, 4] = [type].pack('V')
+          bytes[108, 4] = [type].pack('V') if path.end_with?('.shp')
+          File.binwrite(path, bytes)
+        end
+        before = paths.map { |path| File.binread(path) }
+        load_paths = $LOAD_PATH.map { |path| "-I#{path}" }
+        _stdout, stderr, status = Open3.capture3(RbConfig.ruby, *load_paths, '-e', script,
+                                               filename, type.to_s, index.to_s)
+        assert_true status.success?, "subprocess failed: #{stderr}"
+        assert_equal before, paths.map { |path| File.binread(path) }
+      end
+    end
+  end
+
+  def test_invalid_part_layout_writes_do_not_modify_files
+    [:Arc, :ArcM, :ArcZ, :Polygon, :PolygonM, :PolygonZ, :MultiPatch].each do |type|
+      data = hash_geometry.merge(shape_type: type)
+      before = Shapelib::Shape.new(data.merge('name' => 'before'))
+      cases = [[data, [0, 3, 2]], [data, [0, 0]], [data, [0, 2, 2]],
+               [data, [0, 4]], [empty_geometry(type), [0, 0]]]
+      cases.each do |geometry, starts|
+        invalid = Shapelib::Shape.new(geometry.merge(n_parts: starts.length,
+                                                    part_start: starts,
+                                                    part_type: Array.new(starts.length, :Ring),
+                                                    'name' => 'after'))
+        [[0, -1], [1, -1], [1, 0]].each do |count, index|
+          Dir.mktmpdir('shapelib-test-') do |dir|
+            filename = File.join(dir, 'shapes')
+            Shapelib::ShapeFile.new(filename, type, [['name', Shapelib::String, 10]]) do |file|
+              count.times { file.write(before) }
+            end
+            expected = nil
+            Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+              expected = count.times.map { |record| file.read(record).to_h }
+              error = assert_raise(ArgumentError) { file.write(invalid, index) }
+              assert_match(/part_start\[\d+\]/, error.message)
+              assert_equal count, file.size
+              assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            end
+            Shapelib::ShapeFile.open(filename) do |file|
+              assert_equal count, file.size
+              assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_valid_part_layouts_and_empty_shapes_round_trip
+    [:Arc, :ArcM, :ArcZ, :Polygon, :PolygonM, :PolygonZ, :MultiPatch].each do |type|
+      data = hash_geometry.merge(shape_type: type)
+      # Native builds may omit MultiPatch measures when writing.
+      data[:mvals] = Array.new(data[:n_vertices], 0) if type == :MultiPatch
+      shapes = [Shapelib::Shape.new(data),
+                Shapelib::Shape.new(empty_geometry(type))]
+      shapes.each { |shape| shape['name'] = 'example' }
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'shapes')
+        Shapelib::ShapeFile.new(filename, type, [['name', Shapelib::String, 10]]) do |file|
+          shapes.each_with_index { |shape, index| assert_equal index, file.write(shape) }
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal shapes.length, file.size
+          shapes.each_with_index do |shape, index|
+            assert_equal shape.to_h.merge(shape_id: index), file.read(index).to_h
+          end
+        end
+      end
+    end
+  end
+
+  def test_matching_geometry_and_null_writes_round_trip
+    shapes = [Shapelib::Point.new(1, 2), Shapelib::PointM.new(1, 2, 3),
+              Shapelib::PointZ.new(1, 2, 3, 4), Shapelib::Arc.new([1, 2], [3, 4])]
+    shapes.each do |shape|
+      shape['name'] = 'before'
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'shapes')
+        Shapelib::ShapeFile.new(filename, shape.shape_type, [['name', Shapelib::String, 10]]) do |file|
+          assert_equal 0, file.write(shape)
+          assert_equal 1, file.write(Shapelib::Shape.new(empty_geometry(0)))
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal 2, file.size
+          assert_equal shape.to_h.merge(shape_id: 0), file.read(0).to_h
+          assert_nil file.read(1)
+        end
+      end
+    end
+  end
+
+  def test_incompatible_attribute_types_do_not_modify_files
+    cases = [[Shapelib::String, 12, 0, 7], [Shapelib::String, 12, 0, 1.5],
+             [Shapelib::Logical, 1, 0, 7], [Shapelib::Logical, 1, 0, 1.5],
+             [Shapelib::Integer, 8, 0, '12345678'], [Shapelib::Float, 12, 2, '12345678']]
+    cases.each do |type, width, decimals, value|
+      [[0, -1], [1, -1], [1, 0]].each do |count, index|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'points')
+          fields = [['name', Shapelib::String, 10], ['value', type, width, decimals]]
+          before = type == Shapelib::String ? 'before' : type == Shapelib::Logical ? 'T' : 7
+          Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+            count.times { file.write(Shapelib::Point.new(1, 2, { 'name' => 'before', 'value' => before })) }
+          end
+          expected = nil
+          Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+            expected = count.times.map { |record| file.read(record).to_h }
+            shape = Shapelib::Point.new(9, 9, { 'name' => 'after', 'value' => value })
+            error = assert_raise(TypeError) { file.write(shape, index) }
+            assert_equal 'attribute value has incompatible type for ShapeFile field', error.message
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+          end
+        end
+      end
+    end
+  end
+
+  def test_invalid_logical_values_do_not_modify_files
+    ['true', 'false', 't', 'f', '', '?', 'Y', 'N'].each do |value|
+      [[0, -1], [1, -1], [1, 0]].each do |count, index|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'points')
+          fields = [['name', Shapelib::String, 10], ['flag', Shapelib::Logical, 1]]
+          Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+            count.times { file.write(Shapelib::Point.new(1, 2, { 'name' => 'before', 'flag' => 'T' })) }
+          end
+          expected = expected_bounds = nil
+          Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+            expected = count.times.map { |record| file.read(record).to_h }
+            expected_bounds = [file.minbound, file.maxbound]
+            shape = Shapelib::Point.new(9, 9, { 'name' => 'after', 'flag' => value })
+            error = assert_raise(ArgumentError) { file.write(shape, index) }
+            assert_equal 'attribute flag must start with T or F for a Logical field', error.message
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            assert_equal expected_bounds, [file.minbound, file.maxbound]
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            assert_equal expected_bounds, [file.minbound, file.maxbound]
+          end
+        end
+      end
+    end
+  end
+
+  def test_logical_prefixes_and_null_replacements_round_trip
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      values = ['T', 'F', 'TRUE', 'False', 'Tanything', 'Fanything', nil]
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, [['flag', Shapelib::Logical, 1]]) do |file|
+        values.each { |value| file.write(Shapelib::Point.new(1, 2, { 'flag' => value })) }
+      end
+      values.each_with_index do |value, index|
+        Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+          assert_equal value && value[0], file.read(index)['flag']
+          assert_equal index, file.write(Shapelib::Point.new(3, 4, { 'flag' => 'T' }), index)
+          assert_equal index, file.write(Shapelib::Point.new(5, 6, { 'flag' => value }), index)
+          assert_equal value && value[0], file.read(index)['flag']
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal values.length, file.size
+          assert_equal value && value[0], file.read(index)['flag']
+        end
+      end
+    end
+  end
+
+  def test_compatible_attribute_types_round_trip
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      source = File.join(dir, 'logical')
+      Shapelib::ShapeFile.new(source, Shapelib::Point, [['value', Shapelib::Logical, 1]]) do |file|
+        file.write(Shapelib::Point.new(1, 2, { 'value' => 'T' }))
+      end
+      logical = nil
+      Shapelib::ShapeFile.open(source) { |file| logical = file.read(0) }
+      cases = [[Shapelib::Integer, 8, 0, [7, 7.0, nil]],
+               [Shapelib::Float, 12, 2, [7, 7.5, nil]],
+               [Shapelib::String, 12, 0, ['text', logical, nil]],
+               [Shapelib::Logical, 1, 0, ['T', 'F', logical, nil]]]
+      cases.each_with_index do |(type, width, decimals, values), index|
+        filename = File.join(dir, "points#{index}")
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, [['value', type, width, decimals]]) do |file|
+          values.each_with_index do |value, record|
+            shape = value.is_a?(Shapelib::Shape) ? value : Shapelib::Point.new(1, 2, { 'value' => value })
+            assert_equal record, file.write(shape)
+          end
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal values.length, file.size
+          values.each_with_index do |value, record|
+            shape = file.read(record)
+            assert_equal [1.0], shape.xvals
+            assert_equal [2.0], shape.yvals
+            assert_equal value.is_a?(Shapelib::Shape) ? value['value'] : value, shape['value']
+          end
+        end
+      end
+    end
+  end
+
+  def test_writes_ignore_cleared_attributes_and_null_omitted_fields
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      fields = [['name', Shapelib::String, 10], ['other', Shapelib::Integer, 8]]
+      Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+        shape = Shapelib::Point.new(1, 2, { 'name' => 'valid', 'missing' => 'discard' })
+        shape['missing'] = nil
+        assert_equal 0, file.write(shape)
+        assert_equal 1, file.write(Shapelib::Point.new(3, 4))
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal 2, file.size
+        first = file.read(0)
+        assert_equal 'valid', first['name']
+        assert_nil first['other']
+        second = file.read(1)
+        assert_equal [3.0], second.xvals
+        assert_nil second['name']
+        assert_nil second['other']
+      end
+    end
+  end
+
+  def test_sequential_reads_find_appended_records_after_eof
+    cases = [[[], 1, false], [[1], 1, false], [[1], 3, false],
+             [[1, nil, nil], 3, false], [[nil, nil], 3, false],
+             [[1], 3, true], [[1, nil], :each, false]]
+    cases.each do |records, eof_reads, append_null|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        Shapelib::ShapeFile.new(filename, Shapelib::Point) do |file|
+          records.each do |value|
+            shape = value.nil? ? Shapelib::Shape.new(empty_geometry(:Null)) : Shapelib::Point.new(value, -value)
+            file.write(shape)
+          end
+          expected_ids = records.each_index.reject { |index| records[index].nil? }
+          if eof_reads == :each
+            ids = []
+            file.each { |shape| ids << shape.shape_id }
+            assert_equal expected_ids, ids
+          else
+            expected_ids.each { |index| assert_equal index, file.read.shape_id }
+            eof_reads.times { assert_nil file.read }
+          end
+          file.write(Shapelib::Shape.new(empty_geometry(:Null))) if append_null
+          index = file.write(Shapelib::Point.new(9, -9))
+          shape = file.read
+          assert_not_nil shape
+          assert_equal index, shape.shape_id
+          assert_equal [9.0], shape.xvals
+          assert_equal [-9.0], shape.yvals
+          assert_nil file.read
+        end
+      end
+    end
+  end
+
+  def test_null_records_are_skipped_only_by_sequential_reads
+    [[nil, 1], [1, nil, 2], [1, nil], [nil, nil, 1],
+     [1, nil, nil, 2], [nil, nil]].each do |records|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, [['id', Shapelib::Integer, 8]]) do |file|
+          records.each_with_index do |value, index|
+            shape = if value.nil?
+                      Shapelib::Shape.new(empty_geometry(:Null).merge('id' => index))
+                    else
+                      Shapelib::Point.new(value, -value, { 'id' => index })
+                    end
+            file.write(shape)
+          end
+        end
+        expected = records.each_index.reject { |index| records[index].nil? }
+        Shapelib::ShapeFile.open(filename) do |file|
+          assert_equal records.length, file.size
+          records.each_with_index do |value, index|
+            shape = file.read(index)
+            if value.nil?
+              assert_nil shape
+              following = expected.find { |record| record > index }
+              row = file.read
+              following.nil? ? assert_nil(row) : assert_equal(following, row['id'])
+            else
+              assert_equal [value.to_f], shape.xvals
+              assert_equal index, shape['id']
+            end
+          end
+          file.rewind
+          assert_equal expected, expected.map { file.read['id'] }
+          assert_nil file.read
+          assert_nil file.read
+          2.times do
+            ids = []
+            file.each { |shape| ids << shape['id'] }
+            assert_equal expected, ids
+          end
+          assert_equal records.length, file.size
+        end
+      end
+    end
+  end
+
+  def test_unreadable_dbf_records_raise_and_leave_intact_records_readable
+    [0, 1, 3, 6, 10, :short_count].each do |damage|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, [['name', :String, 10]]) do |file|
+          file.write(Shapelib::Point.new(1, 2, 'name' => 'first'))
+          file.write(Shapelib::Point.new(3, 4, 'name' => 'second'))
+        end
+        if damage != :short_count
+          header = File.binread("#{filename}.dbf", 12)
+          header_length, record_length = header[8, 4].unpack('v2')
+          File.truncate("#{filename}.dbf", header_length + record_length + damage)
+        else
+          File.open("#{filename}.dbf", 'rb+') { |file| file.seek(4); file.write([1].pack('V')) }
+        end
+        [:direct, :sequential, :each].each do |method|
+          Shapelib::ShapeFile.open(filename) do |file|
+            first = file.read(0).to_h
+            assert_equal 'first', first['name']
+            yielded = []
+            error = assert_raise(IOError) do
+              case method
+              when :direct then file.read(1)
+              when :sequential then file.read
+              when :each then file.each { |shape| yielded << shape.to_h }
+              end
+            end
+            assert_equal 'cannot read DBF record 1', error.message
+            assert_equal [first], yielded if method == :each
+            assert_nil file.read
+            assert_equal first, file.read(0).to_h
+          end
+        end
+      end
+    end
+  end
+
+  def test_null_attributes_and_files_without_attributes_remain_readable
+    [:nulls, :no_fields, :missing_dbf].each do |kind|
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        fields = kind == :no_fields ? [] : [['name', :String, 10], ['amount', :Float, 12, 2], ['flag', :Logical, 1]]
+        Shapelib::ShapeFile.new(filename, Shapelib::Point, fields) do |file|
+          2.times { |index| file.write(Shapelib::Point.new(index, index + 1)) }
+        end
+        File.unlink("#{filename}.dbf") if kind == :missing_dbf
+        Shapelib::ShapeFile.open(filename) do |file|
+          shapes = []
+          file.each { |shape| shapes << shape }
+          assert_equal 2, shapes.length
+          shapes.each_with_index do |shape, index|
+            assert_equal [index.to_f], shape.xvals
+            assert_equal [(index + 1).to_f], shape.yvals
+            %w[name amount flag].each { |name| assert_nil shape[name] }
+            assert_equal shape.to_h, file.read(index).to_h
+          end
+          assert_nil file.read
+        end
+      end
+    end
+  end
+
+  def test_geometry_only_reads_and_rejects_writes
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      Shapelib::ShapeFile.new(filename, Shapelib::Point) do |file|
+        file.write(Shapelib::Point.new(1, 2))
+      end
+      File.unlink("#{filename}.dbf")
+      paths = %w[shp shx].map { |suffix| "#{filename}.#{suffix}" }
+      contents = paths.map { |path| File.binread(path) }
+      Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+        assert_equal 1, file.size
+        assert_equal(-1, file.field_count)
+        assert_nil file.fields
+        assert_equal [1.0], file.read(0).xvals
+        shapes = []
+        file.each { |shape| shapes << shape }
+        assert_equal 1, shapes.size
+        assert_equal [2.0], shapes.first.yvals
+        assert_raise(IOError) { file.write(Shapelib::Point.new(3, 4)) }
+      end
+      assert_equal contents, paths.map { |path| File.binread(path) }
+    end
+  end
+
+  def test_hash_constructor_rejects_negative_counts
+    [:n_vertices, :n_parts].each do |key|
+      data = hash_geometry
+      data[key] = -1
+      assert_raise(ArgumentError) { Shapelib::Shape.new(data) }
+    end
+  end
+
+  def test_hash_constructor_rejects_short_arrays
+    [:part_type, :part_start, :xvals, :yvals, :zvals, :mvals].each do |key|
+      data = hash_geometry
+      count = data[[:part_type, :part_start].include?(key) ? :n_parts : :n_vertices]
+      data[key] = data[key].take(count - 1)
+      error = assert_raise(ArgumentError) { Shapelib::Shape.new(data) }
+      assert_match(/#{key}.*#{count}/, error.message)
+    end
+  end
+
+  def test_hash_constructor_rejects_out_of_bounds_part_starts
+    [:ArcZ, :PolygonZ].each do |type|
+      [-1, 5].each do |start|
+        data = hash_geometry.merge(shape_type: type, part_start: [0, start])
+        error = assert_raise(ArgumentError) { Shapelib::Shape.new(data) }
+        assert_equal 'part_start[1] must be between 0 and 4', error.message
+      end
+    end
+    GC.start
+  end
+
+  def test_hash_constructor_preserves_part_wkt
+    { ArcZ: 'MULTILINESTRING((0 1, 4 5), (8 9, 12 13))',
+      PolygonZ: 'POLYGON((0 1, 4 5), (8 9, 12 13))' }.each do |type, wkt|
+      shape = Shapelib::Shape.new(hash_geometry.merge(shape_type: type))
+      assert_equal [0, 2], shape.part_start
+      assert_equal wkt, shape.wkt
+    end
+  end
+
+  def test_coordinate_reads_and_iteration_with_frozen_shapes
+    [false, true].each do |frozen|
+      [false, true].each do |cache_first|
+        cases = [[Shapelib::Point.new(1, 2), [[2.0, 1.0]]],
+                 [Shapelib::Arc.new([[1, 2], [3, 4]], [[5, 6], [7, 8]]),
+                  [[2.0, 1.0], [4.0, 3.0], [6.0, 5.0], [8.0, 7.0]]],
+                 [Shapelib::Shape.new(empty_geometry(:Null)), []]]
+        cases.each do |shape, expected|
+          cached = shape.latlngs if cache_first
+          shape.freeze if frozen
+          before = shape.instance_variables.map { |name| [name, shape.instance_variable_get(name)] }
+          coordinates = shape.latlngs
+          assert_equal expected, coordinates
+          points = []
+          assert_equal expected, shape.each { |point| points << point }
+          assert_equal expected, points
+          if frozen
+            assert_equal before, shape.instance_variables.map { |name| [name, shape.instance_variable_get(name)] }
+          end
+          assert_same cached, coordinates if cache_first
+          assert_same coordinates, shape.latlngs unless frozen && !cache_first
+        end
+      end
+    end
+  end
+
+  def test_rewind_polygon_refreshes_cached_latlngs_and_iteration
+    [Shapelib::Polygon, Shapelib::PolygonM, Shapelib::PolygonZ].each do |klass|
+      [false, true].each do |cache_first|
+        shape = klass.new([0, 0], [2, 0], [2, 1], [0, 0])
+        before = shape.yvals.zip(shape.xvals)
+        shape.latlngs if cache_first
+        assert_equal true, shape.rewind_polygon
+        expected = shape.yvals.zip(shape.xvals)
+        assert_not_equal before, expected
+        assert_equal expected, shape.latlngs
+        points = []
+        shape.each { |point| points << point }
+        assert_equal expected, points
+        refreshed = shape.latlngs
+        assert_equal false, shape.rewind_polygon
+        assert_same refreshed, shape.latlngs
+      end
+    end
+  end
+
+  def test_rewind_polygon_rejects_frozen_shapes_without_mutation
+    [Shapelib::Polygon, Shapelib::PolygonM, Shapelib::PolygonZ].each do |klass|
+      [false, true].each do |cache_first|
+        shape = klass.new([0, 0], [2, 0], [2, 1], [0, 0])
+        cached = shape.latlngs if cache_first
+        before = shape.to_h
+        shape.freeze
+        assert_raise(FrozenError) { shape.rewind_polygon }
+        assert_equal before, shape.to_h
+        assert_same cached, shape.latlngs if cache_first
+      end
+    end
+  end
+
+  def test_hash_constructor_preserves_empty_parts
+    { ArcZ: 'MULTILINESTRING', PolygonZ: 'POLYGON' }.each do |type, prefix|
+      { [0, 0] => '((), (0 1, 4 5, 8 9, 12 13))',
+        [0, 4] => '((0 1, 4 5, 8 9, 12 13), ())' }.each do |starts, body|
+        shape = Shapelib::Shape.new(hash_geometry.merge(shape_type: type, part_start: starts))
+        assert_equal starts, shape.part_start
+        assert_equal prefix + body, shape.wkt
+      end
+    end
+  end
+
+  def test_wkt_preserves_many_empty_parts
+    { Arc: 'MULTILINESTRING', ArcM: 'MULTILINESTRING', ArcZ: 'MULTILINESTRING',
+      Polygon: 'POLYGON', PolygonM: 'POLYGON', PolygonZ: 'POLYGON' }.each do |type, prefix|
+      [2, 4, 8].each do |count|
+        data = empty_geometry(type).merge(n_parts: count,
+                                         part_type: Array.new(count, 0),
+                                         part_start: Array.new(count, 0))
+        expected = "#{prefix}(#{Array.new(count, '()').join(', ')})"
+        assert_equal expected, Shapelib::Shape.new(data).wkt
+      end
+      parts = Array.new(32, '()') + ['(1 2, 3 4)'] + Array.new(32, '()')
+      data = empty_geometry(type).merge(n_vertices: 2, n_parts: parts.length,
+                                       part_type: Array.new(parts.length, 0),
+                                       part_start: Array.new(33, 0) + Array.new(32, 2),
+                                       xvals: [1, 3], yvals: [2, 4],
+                                       zvals: [0, 0], mvals: [nil, nil])
+      assert_equal "#{prefix}(#{parts.join(', ')})", Shapelib::Shape.new(data).wkt
+    end
+  end
+
+  def test_multipoint_wkt_preserves_closing_parenthesis
+    [Shapelib::MultiPoint, Shapelib::MultiPointM, Shapelib::MultiPointZ].each do |klass|
+      assert_equal 'MULTIPOINT()', klass.new.wkt
+      assert_equal 'MULTIPOINT(1 2, 3 4)', klass.new([1, 2], [3, 4]).wkt
+    end
+  end
+
+  def test_hash_constructor_preserves_part_start_normalization_and_prefix_counts
+    [:ArcZ, :PolygonZ].each do |type|
+      expected = Shapelib::Shape.new(hash_geometry.merge(shape_type: type)).to_h
+      [-1, 1, 5].each do |first|
+        data = hash_geometry.merge(shape_type: type, part_start: [first, 2, -1, 5])
+        assert_equal expected, Shapelib::Shape.new(data).to_h
+      end
+    end
+  end
+
+  def test_hash_constructor_preserves_matching_counts
+    data = hash_geometry
+    data['name'] = 'example'
+    assert_equal data, Shapelib::Shape.new(data).to_h
+  end
+
+  def test_hash_constructor_preserves_explicit_prefix_counts
+    data = hash_geometry
+    data[:n_parts] = 1
+    data[:n_vertices] = 2
+    shape = Shapelib::Shape.new(data)
+    assert_equal 1, shape.n_parts
+    assert_equal 2, shape.n_vertices
+    [:xvals, :yvals, :zvals, :mvals, :part_start, :part_type].each do |key|
+      count = [:part_start, :part_type].include?(key) ? 1 : 2
+      assert_equal data[key].take(count), shape.to_h[key]
+    end
+  end
+
+  def test_hash_constructor_reads_each_field_once
+    data = hash_geometry
+    reads = Hash.new(0)
+    input = Object.new
+    input.define_singleton_method(:[]) do |key|
+      reads[key] += 1
+      raise 'field fetched twice' if reads[key] > 1
+      data[key]
+    end
+    assert_equal data, Shapelib::Shape.new(input).to_h
+    expected = [:shape_type, :shape_id, :n_parts, :n_vertices,
+                :part_type, :part_start, :xvals, :yvals, :zvals, :mvals]
+    assert_equal expected.sort, reads.keys.sort
+    assert_equal [1], reads.values.uniq
+  end
+
+  def test_hash_constructor_preserves_conversion_exceptions_and_recovers
+    [2, 512].each do |size|
+      [:part_type, :part_start, :xvals, :yvals, :zvals, :mvals].each do |key|
+        [0, size - 1].each do |index|
+          data = { shape_type: :ArcZ, n_parts: size, n_vertices: size,
+                   part_type: Array.new(size, :Ring), part_start: (0...size).to_a,
+                   xvals: Array.new(size, 1.0), yvals: Array.new(size, 2.0),
+                   zvals: Array.new(size, 4.0), mvals: Array.new(size, 3.0) }
+          expected = Shapelib::Shape.new(data).to_h
+          original = key == :part_type ? 5 : data[key][index]
+          error = RuntimeError.new('conversion failed')
+          fail_conversion = true
+          value = Object.new
+          conversion = [:part_type, :part_start].include?(key) ? :to_int : :to_f
+          value.define_singleton_method(conversion) do
+            GC.start
+            raise error if fail_conversion
+            original
+          end
+          data[key][index] = value
+          assert_same error, assert_raise(RuntimeError) { Shapelib::Shape.new(data) }
+          fail_conversion = false
+          assert_equal expected, Shapelib::Shape.new(data).to_h
+        end
+      end
+    end
+  end
+
+  def test_convenience_constructors_preserve_conversion_exceptions_and_recover
+    [2, 512].each do |size|
+      [:single, :multipart, :multipoint, :multipoint_list].each do |form|
+        [:to_f, :x, :y, :m, :z].each do |failure|
+          points = Array.new(size) { [1, 2, 3, 4] }
+          build = case form
+                  when :single then -> { Shapelib::ArcZ.new(*points) }
+                  when :multipart then -> { Shapelib::ArcZ.new(*points.map { |point| [point] }) }
+                  when :multipoint then -> { Shapelib::MultiPointZ.new(*points) }
+                  when :multipoint_list then -> { Shapelib::MultiPointZ.new(points) }
+                  end
+          expected = build.call.to_h
+          error = RuntimeError.new('conversion failed')
+          fail_conversion = true
+          value = Object.new
+          if failure == :to_f
+            value.define_singleton_method(:to_f) do
+              GC.start
+              raise error if fail_conversion
+              4.0
+            end
+            points[-1][-1] = value
+          else
+            [:x, :y, :m, :z].each_with_index do |method, index|
+              value.define_singleton_method(method) do
+                GC.start
+                raise error if fail_conversion && method == failure
+                index + 1.0
+              end
+            end
+            points[-1] = value
+          end
+          assert_same error, assert_raise(RuntimeError) { build.call }
+          fail_conversion = false
+          assert_equal expected, build.call.to_h
+        end
+      end
+    end
+  end
+
+  def test_hash_constructor_snapshots_arrays_before_numeric_conversion
+    [:part_type, :part_start, :xvals, :yvals, :zvals, :mvals].each do |key|
+      [:grow, :clear].each do |mutation|
+        data = hash_geometry
+        expected = data.transform_values { |value| value.is_a?(Array) ? value.dup : value }
+        array = data[key]
+        original = array[0]
+        number = key == :part_type ? 5 : original
+        conversion = [:part_type, :part_start].include?(key) ? :to_int : :to_f
+        value = Object.new
+        value.define_singleton_method(conversion) do
+          mutation == :grow ? array.concat([original] * 16) : array.clear
+          number
+        end
+        array[0] = value
+        assert_equal expected, Shapelib::Shape.new(data).to_h
+        assert_equal mutation == :grow ? expected[key].length + 16 : 0, array.length
+      end
+    end
+  end
+
+  def test_hash_constructor_snapshots_later_arrays_before_numeric_conversion
+    [:part_type, :part_start, :xvals, :yvals, :zvals, :mvals].each_cons(2) do |key, later_key|
+      data = hash_geometry
+      expected = data.transform_values { |value| value.is_a?(Array) ? value.dup : value }
+      later = data[later_key]
+      number = key == :part_type ? 5 : data[key][0]
+      conversion = [:part_type, :part_start].include?(key) ? :to_int : :to_f
+      value = Object.new
+      value.define_singleton_method(conversion) do
+        later.clear
+        number
+      end
+      data[key][0] = value
+      assert_equal expected, Shapelib::Shape.new(data).to_h
+      assert_empty later
+    end
+  end
+
+  def test_hash_constructor_preserves_optional_xy_arrays
+    data = hash_geometry
+    data[:xvals] = data[:yvals] = nil
+    shape = Shapelib::Shape.new(data)
+    assert_equal [0.0] * data[:n_vertices], shape.xvals
+    assert_equal [0.0] * data[:n_vertices], shape.yvals
+    assert_equal data[:zvals], shape.zvals
+    assert_equal data[:mvals], shape.mvals
+  end
+
+  def test_hash_constructor_still_requires_counts_and_arrays
+    [:n_vertices, :n_parts, :part_type, :part_start].each do |key|
+      data = hash_geometry
+      data[key] = nil
+      assert_raise(TypeError) { Shapelib::Shape.new(data) }
+    end
+    [:zvals, :mvals].each do |key|
+      data = hash_geometry
+      data[key] = nil
+      error = assert_raise(RuntimeError) { Shapelib::Shape.new(data) }
+      assert_equal "missing #{key}", error.message
+    end
+  end
+
+  def test_empty_points_reject_coordinate_reads_and_wkt
+    { Point: [:m, :z], PointM: [:z], PointZ: [] }.each do |type, absent|
+      shape = Shapelib::Shape.new(empty_geometry(type))
+      assert_equal 0, shape.n_vertices
+      assert_equal type, shape.to_h[:shape_type]
+      ([:x, :y, :m, :z, :wkt, :to_s] - absent).each do |method|
+        error = assert_raise(ArgumentError) { shape.public_send(method) }
+        assert_equal 'point has no vertices', error.message
+      end
+      absent.each { |method| assert_nil shape.public_send(method) }
+    end
+  end
+
+  def test_empty_lines_reject_wkt
+    [Shapelib::Arc, Shapelib::ArcM, Shapelib::ArcZ].each do |klass|
+      [klass.new(:Ring), Shapelib::Shape.new(empty_geometry(klass))].each do |shape|
+        assert_equal 0, shape.n_vertices
+        [:wkt, :to_s].each do |method|
+          error = assert_raise(ArgumentError) { shape.public_send(method) }
+          assert_equal 'cannot format an empty line', error.message
+        end
+      end
+    end
+  end
+
+  def test_constructors_reject_unsupported_numeric_shape_types
+    [-1, 2, 4, 32, 99].each do |type|
+      error = assert_raise(ArgumentError) { Shapelib::Shape.new(empty_geometry(type)) }
+      assert_equal "invalid shape_type #{type}", error.message
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        error = assert_raise(ArgumentError) { Shapelib::ShapeFile.new(File.join(dir, 'shapes'), type) }
+        assert_equal "invalid shape_type #{type}", error.message
+        assert_empty Dir.children(dir)
+      end
+    end
+  end
+
+  def test_constructors_accept_supported_numeric_shape_types
+    { 0 => :Null, 1 => :Point, 3 => :Arc, 5 => :Polygon, 8 => :MultiPoint,
+      11 => :PointZ, 13 => :ArcZ, 15 => :PolygonZ, 18 => :MultiPointZ,
+      21 => :PointM, 23 => :ArcM, 25 => :PolygonM, 28 => :MultiPointM,
+      31 => :MultiPatch }.each do |type, name|
+      assert_equal name, Shapelib::Shape.new(empty_geometry(type)).shape_type
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'shapes')
+        Shapelib::ShapeFile.new(filename, type) do |file|
+          assert_equal name, file.shape_type
+          assert_equal 0, file.size
+        end
+        Shapelib::ShapeFile.open(filename) { |file| assert_equal name, file.shape_type }
+      end
+    end
+  end
+
+  def test_null_shape_types_reject_wkt
+    { Null: 0, 0 => 0 }.each do |type, number|
+      shape = Shapelib::Shape.new(empty_geometry(type))
+      assert_equal :Null, shape.shape_type
+      assert_equal shape.shape_type, shape.to_h[:shape_type]
+      [:wkt, :to_s].each do |method|
+        error = assert_raise(ArgumentError) { shape.public_send(method) }
+        assert_equal "unsupported WKT shape type #{number}", error.message
+      end
+    end
+  end
+
+  def test_new_point_selects_constructor_with_optional_attributes
+    [[[1, 2], Shapelib::Point, [1.0, 2.0, nil, nil]],
+     [[1, 2, 3], Shapelib::PointM, [1.0, 2.0, 3.0, nil]],
+     [[1, 2, 3, 4], Shapelib::PointZ, [1.0, 2.0, 3.0, 4.0]]].each do |args, klass, coordinates|
+      [false, true].each do |attributes|
+        point = Shapelib.new_point(*(attributes ? args + [{ 'name' => 'example' }] : args))
+        assert_instance_of klass, point
+        assert_equal coordinates, [:x, :y, :m, :z].map { |method| point.public_send(method) }
+        attributes ? assert_equal('example', point['name']) : assert_nil(point['name'])
+      end
+    end
+  end
+
+  def test_new_point_preserves_explicit_nil_arguments
+    [[[1, 2, nil], Shapelib::PointM, [1.0, 2.0, nil, nil]],
+     [[1, 2, 3, nil], Shapelib::PointM, [1.0, 2.0, 3.0, nil]],
+     [[1, 2, 3, 4, nil], Shapelib::PointZ, [1.0, 2.0, 3.0, 4.0]]].each do |args, klass, coordinates|
+      point = Shapelib.new_point(*args)
+      assert_instance_of klass, point
+      assert_equal coordinates, [:x, :y, :m, :z].map { |method| point.public_send(method) }
+    end
+  end
+
+  def test_new_point_rejects_invalid_arguments
+    [[], [1], [1, 2, 3, 4, {}, 6]].each do |args|
+      assert_raise(ArgumentError) { Shapelib.new_point(*args) }
+    end
+    [42, 'attributes', Object.new].each do |attributes|
+      assert_raise(TypeError) { Shapelib.new_point(1, 2, 3, 4, attributes) }
+    end
+  end
+
+  def test_point_measures_preserve_negatives_and_recognize_no_data
+    measure_cases.each do |value, expected|
+      [Shapelib::PointM.new(-1, -2, value), Shapelib::PointZ.new(-1, -2, value, -3)].each do |point|
+        assert_equal expected, point.m
+        assert_equal [expected], point.mvals
+        assert_equal [expected], point.to_h[:mvals]
+        assert_equal [-1.0, -2.0, expected, point.z || 0.0], point.minbound
+        assert_equal point.minbound, point.maxbound
+      end
+    end
+  end
+
+  def test_geometry_measure_arrays_use_the_same_no_data_rules
+    [Shapelib::ArcM, Shapelib::ArcZ, Shapelib::MultiPointM, Shapelib::MultiPointZ].each do |klass|
+      measure_cases.each do |value, expected|
+        shape = klass.new([-1, -2, value, -3])
+        hash = shape.to_h.merge(mvals: [value], part_type: shape.part_type || [], part_start: shape.part_start || [])
+        [shape, Shapelib::Shape.new(hash)].each do |geometry|
+          assert_equal [expected], geometry.mvals
+          assert_equal [expected], geometry.to_h[:mvals]
+          assert_equal expected, geometry.minbound[2]
+          assert_equal expected, geometry.maxbound[2]
+        end
+      end
+    end
+  end
+
+  def test_file_bounds_use_the_same_measure_rules_as_shapes
+    [Shapelib::PointM, Shapelib::PointZ].each do |klass|
+      measure_cases.each do |value, expected|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'measures')
+          point = klass == Shapelib::PointM ? klass.new(-1, -2, value) : klass.new(-1, -2, value, -3)
+          bounds = [-1.0, -2.0, expected, point.z || 0.0]
+          Shapelib::ShapeFile.new(filename, klass) do |file|
+            file.write(point)
+            assert_equal bounds, file.minbound
+            assert_equal bounds, file.maxbound
+            assert_equal point.minbound, file.minbound
+            assert_equal point.maxbound, file.maxbound
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            shape = file.read(0)
+            assert_equal bounds, file.minbound
+            assert_equal bounds, file.maxbound
+            assert_equal shape.minbound, file.minbound
+            assert_equal shape.maxbound, file.maxbound
+          end
+        end
+      end
+    end
+  end
+
+  def test_measure_files_preserve_negatives_and_legacy_nulls
+    [[Shapelib::PointM, 128], [Shapelib::PointZ, 136]].each do |klass, offset|
+      [-1.0, -1e38, nil, -2e-38].each do |value|
+        Dir.mktmpdir('shapelib-test-') do |dir|
+          filename = File.join(dir, 'measures')
+          point = klass == Shapelib::PointM ? klass.new(1, 2, value) : klass.new(1, 2, value, 3)
+          Shapelib::ShapeFile.new(filename, klass) { |file| file.write(point) }
+          stored = File.binread("#{filename}.shp", 8, offset).unpack('E').first
+          assert_equal value.nil? ? -2e38 : value, stored
+          expected = value == -2e-38 ? nil : value
+          Shapelib::ShapeFile.open(filename) do |file|
+            shape = file.read(0)
+            assert_equal [expected], shape.mvals
+            assert_equal [expected], shape.to_h[:mvals]
+            assert_equal expected, shape.minbound[2]
+            assert_equal expected, shape.maxbound[2]
+          end
+        end
+      end
+    end
+  end
+
+  def test_nonempty_point_coordinates_and_wkt
+    [Shapelib::Point.new(1, 2), Shapelib::PointM.new(1, 2, 3),
+     Shapelib::PointZ.new(1, 2, 3, 4)].each_with_index do |shape, index|
+      assert_equal 1.0, shape.x
+      assert_equal 2.0, shape.y
+      index == 0 ? assert_nil(shape.m) : assert_equal(3.0, shape.m)
+      index == 2 ? assert_equal(4.0, shape.z) : assert_nil(shape.z)
+      assert_equal 'POINT(1 2)', shape.wkt
+      assert_equal shape.wkt, shape.to_s
+    end
+  end
+
+  def test_nonempty_single_line_wkt
+    [Shapelib::Arc, Shapelib::ArcM, Shapelib::ArcZ].each do |klass|
+      shape = klass.new([1, 2], [3, 4])
+      assert_equal 'LINESTRING(1 2, 3 4)', shape.wkt
+      assert_equal shape.wkt, shape.to_s
+    end
+  end
+
+  def test_geometry_constructors_reject_empty_inputs
+    part = [[0, 0], [1, 1]]
+    classes = [Shapelib::Arc, Shapelib::ArcM, Shapelib::ArcZ,
+               Shapelib::Polygon, Shapelib::PolygonM, Shapelib::PolygonZ, Shapelib::MultiPatch]
+    classes.each do |klass|
+      [[], [[]], [[], part], [part, []]].each do |args|
+        assert_raise(ArgumentError) { klass.new(*args) }
+      end
+    end
+  end
+
+  def test_multipart_constructor_rejects_non_array_part
+    error = assert_raise(ArgumentError) { Shapelib::Arc.new([[0, 0], [1, 1]], nil) }
+    assert_equal 'arg 1 must be Array', error.message
+  end
+
+  def test_part_starts_initialize_under_gc_stress
+    script = <<~'RUBY'
+      Process.setrlimit(Process::RLIMIT_CORE, 0, 0) if Process.const_defined?(:RLIMIT_CORE)
+      require 'shapelib'
+      shape = Shapelib::Arc.new([[1, 2], [3, 4]], [[5, 6], [7, 8]])
+      previous_stress = GC.stress
+      begin
+        GC.stress = true
+        results = 5.times.map { shape.part_start }
+      ensure
+        GC.stress = previous_stress
+      end
+      abort "unexpected part starts: #{results.inspect}" unless results.all? { |parts| parts == [0, 2] }
+    RUBY
+    load_paths = $LOAD_PATH.map { |path| "-I#{path}" }
+    _stdout, stderr, status = Open3.capture3(RbConfig.ruby, *load_paths, '-e', script)
+    assert_true status.success?, "subprocess failed: #{stderr}"
+  end
+
+  def test_geometry_constructors_accept_single_and_multiple_parts
+    part = [[0, 0], [1, 0], [1, 1], [0, 0]]
+    [Shapelib::Arc, Shapelib::Polygon].each do |klass|
+      single = klass.new(*part)
+      assert_equal 1, single.n_parts
+      assert_equal 4, single.n_vertices
+      assert_equal [0.0, 1.0, 1.0, 0.0], single.xvals
+      multiple = klass.new(part, part)
+      assert_equal 2, multiple.n_parts
+      assert_equal 8, multiple.n_vertices
+      assert_equal single.xvals * 2, multiple.xvals
+    end
+  end
+
+  def test_geometry_constructors_accept_large_integer_coordinates
+    classes = [Shapelib::Arc, Shapelib::ArcM, Shapelib::ArcZ,
+               Shapelib::Polygon, Shapelib::PolygonM, Shapelib::PolygonZ, Shapelib::MultiPatch]
+    classes.each do |klass|
+      [2**64, -(2**64)].each do |value|
+        points = [[value, 2], [3, 4], [5, 6], [value, 2]]
+        shape = klass.new(*points)
+        assert_equal 1, shape.n_parts
+        assert_equal points.length, shape.n_vertices
+        assert_equal [value.to_f, 3.0, 5.0, value.to_f], shape.xvals
+        assert_equal [2.0, 4.0, 6.0, 2.0], shape.yvals
+        assert_equal klass.new(*points.map { |point| point.map(&:to_f) }).to_h, shape.to_h
+      end
+    end
+  end
+
+  def test_multipart_constructor_accepts_explicit_part_type
+    shape = Shapelib::MultiPatch.new([:TriangleStrip, [0, 0], [1, 0], [0, 1]])
+    assert_equal 1, shape.n_parts
+    assert_equal 3, shape.n_vertices
+    assert_equal [:TriangleStrip], shape.part_type
+    assert_equal [0.0, 1.0, 0.0], shape.xvals
+  end
+
+  def test_geometry_constructors_reject_unknown_part_types
+    part = [[0, 0], [1, 0], [0, 1]]
+    data = Shapelib::MultiPatch.new([:Ring, *part]).to_h
+    [:Unknown, 'Unknown'].each do |type|
+      assert_raise(ArgumentError) { Shapelib::MultiPatch.new(type, *part) }
+      assert_raise(ArgumentError) { Shapelib::MultiPatch.new([type, *part]) }
+      assert_raise(ArgumentError) { Shapelib::MultiPatch.new([:Ring, *part], [type, *part]) }
+      assert_raise(ArgumentError) { Shapelib::Shape.new(data.merge(part_type: [type])) }
+    end
+    [-1, 6, 99].each do |type|
+      error = assert_raise(ArgumentError) { Shapelib::Shape.new(data.merge(part_type: [type])) }
+      assert_equal "invalid part_type #{type}", error.message
+    end
+    number = Object.new
+    number.define_singleton_method(:to_int) { 6 }
+    assert_raise(ArgumentError) { Shapelib::Shape.new(data.merge(part_type: [number])) }
+  end
+
+  def test_supported_part_types_round_trip
+    types = [:TriangleStrip, :TriangleFan, :OuterRing, :InnerRing, :FirstRing, :Ring]
+    part = [[0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0]]
+    shapes = []
+    types.each_with_index do |type, index|
+      single = Shapelib::MultiPatch.new(type, *part)
+      assert_equal [type], single.part_type
+      [type, type.to_s].each do |label|
+        shape = Shapelib::MultiPatch.new([label, *part])
+        assert_equal single.to_h, shape.to_h
+        shapes << shape
+      end
+      number = Object.new
+      number.define_singleton_method(:to_int) { index }
+      [type, type.to_s, index, number].each do |value|
+        shape = Shapelib::Shape.new(single.to_h.merge(part_type: [value]))
+        assert_equal single.to_h, shape.to_h
+        shapes << shape
+      end
+    end
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'patches')
+      Shapelib::ShapeFile.new(filename, Shapelib::MultiPatch) do |file|
+        shapes.each_with_index { |shape, index| assert_equal index, file.write(shape) }
+      end
+      Shapelib::ShapeFile.open(filename) do |file|
+        assert_equal shapes.length, file.size
+        shapes.each_with_index do |shape, index|
+          assert_equal shape.to_h.merge(shape_id: index), file.read(index).to_h
+        end
+      end
+    end
+  end
+
+  def test_invalid_native_part_types_do_not_modify_files
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      source = File.join(dir, 'source')
+      fields = [['name', Shapelib::String, 10]]
+      shape = Shapelib::MultiPatch.new([:Ring, [9, 9, 0, 0], [10, 9, 0, 0], [9, 10, 0, 0]])
+      shape['name'] = 'after'
+      Shapelib::ShapeFile.new(source, Shapelib::MultiPatch, fields) { |file| file.write(shape) }
+      [-1, 6, 99].each do |type|
+        # First record: 100-byte header, 8-byte record header, then the
+        # MultiPatch type, bounds, counts, part starts, and part types.
+        File.open("#{source}.shp", 'rb+') do |file|
+          file.seek(108 + 36)
+          parts = file.read(4).unpack('V').first
+          file.seek(108 + 44 + 4 * parts)
+          file.write([type].pack('l<'))
+        end
+        invalid = nil
+        Shapelib::ShapeFile.open(source) { |file| invalid = file.read(0) }
+        assert_equal [type], invalid.part_type
+        [[0, -1], [1, -1], [1, 0]].each do |count, index|
+          filename = File.join(dir, 'destination')
+          before = Shapelib::MultiPatch.new([:Ring, [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]])
+          before['name'] = 'before'
+          Shapelib::ShapeFile.new(filename, Shapelib::MultiPatch, fields) do |file|
+            count.times { file.write(before) }
+          end
+          expected = expected_bounds = nil
+          Shapelib::ShapeFile.open(filename, 'rb+') do |file|
+            expected = count.times.map { |record| file.read(record).to_h }
+            expected_bounds = [file.minbound, file.maxbound]
+            error = assert_raise(ArgumentError) { file.write(invalid, index) }
+            assert_equal "part_type[0] must be between 0 and 5 (got #{type})", error.message
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            assert_equal expected_bounds, [file.minbound, file.maxbound]
+          end
+          Shapelib::ShapeFile.open(filename) do |file|
+            assert_equal count, file.size
+            assert_equal expected, count.times.map { |record| file.read(record).to_h }
+            assert_equal expected_bounds, [file.minbound, file.maxbound]
+          end
+        end
+      end
+    end
+  end
+
+  def test_multipart_constructors_snapshot_later_parts_before_conversion
+    classes = [Shapelib::Arc, Shapelib::ArcM, Shapelib::ArcZ,
+               Shapelib::Polygon, Shapelib::PolygonM, Shapelib::PolygonZ, Shapelib::MultiPatch]
+    classes.each do |klass|
+      [:grow, :clear].each do |mutation|
+        first = [[1, 2, 3, 4], [5, 6, 7, 8]]
+        later = [:Ring, [9, 10, 11, 12]]
+        expected = klass.new(first, later).to_h
+        number = Object.new
+        number.define_singleton_method(:to_f) do
+          mutation == :grow ? later.concat([[13, 14, 15, 16]] * 16) : later.clear
+          2.0
+        end
+        first[0][1] = number
+        assert_equal expected, klass.new(first, later).to_h
+        assert_equal mutation == :grow ? 18 : 0, later.length
+      end
+    end
+  end
+
+  def test_convenience_constructors_snapshot_later_coordinates_before_conversion
+    [:single, :multipart, :multipoint].each do |form|
+      [:replace, :clear].each do |mutation|
+        first = [1, 2, 3, 4]
+        later = [5, 6, 7, 8]
+        build = case form
+                when :single then -> { Shapelib::ArcZ.new(first, later) }
+                when :multipart then -> { Shapelib::ArcZ.new([first], [later]) }
+                when :multipoint then -> { Shapelib::MultiPointZ.new(first, later) }
+                end
+        expected = build.call.to_h
+        number = Object.new
+        number.define_singleton_method(:to_f) do
+          mutation == :replace ? later.replace([50, 60, 70, 80]) : later.clear
+          2.0
+        end
+        first[1] = number
+        assert_equal expected, build.call.to_h
+        assert_equal mutation == :replace ? [50, 60, 70, 80] : [], later
+      end
+    end
+  end
+
+  def test_convenience_constructors_snapshot_current_coordinates_before_conversion
+    [:single, :multipart, :multipoint].each do |form|
+      [:grow, :clear].each do |mutation|
+        point = [1, 2, 3, 4]
+        build = case form
+                when :single then -> { Shapelib::ArcZ.new(point) }
+                when :multipart then -> { Shapelib::ArcZ.new([point]) }
+                when :multipoint then -> { Shapelib::MultiPointZ.new(point) }
+                end
+        expected = build.call.to_h
+        number = Object.new
+        number.define_singleton_method(:to_f) do
+          mutation == :grow ? point.concat([9] * 16) : point.clear
+          GC.start
+          2.0
+        end
+        point[1] = number
+        assert_equal expected, build.call.to_h
+        assert_equal mutation == :grow ? 20 : 0, point.length
+      end
+    end
+  end
+
+  def test_geometry_coordinate_defaults_are_preserved
+    shape = Shapelib::Arc.new([1, 2], [])
+    assert_equal [1.0, 0.0], shape.xvals
+    assert_equal [2.0, 0.0], shape.yvals
+  end
+
+  def test_point_and_multipoint_hash_round_trips
+    [Shapelib::Point, Shapelib::PointM, Shapelib::PointZ,
+     Shapelib::MultiPoint, Shapelib::MultiPointM, Shapelib::MultiPointZ].each do |klass|
+      shapes = if klass.name.include?('MultiPoint')
+                 [klass.new([1, 2, nil, 4], [5, 6, -1, 8]), klass.new]
+               elsif klass == Shapelib::Point
+                 [klass.new(1, 2), klass.new(5, 6)]
+               elsif klass == Shapelib::PointM
+                 [klass.new(1, 2, nil), klass.new(5, 6, -1)]
+               else
+                 [klass.new(1, 2, nil, 4), klass.new(5, 6, -1, 8)]
+               end
+      shapes.each do |shape|
+        shape['name'] = 'example'
+        data = shape.to_h
+        copy = Shapelib::Shape.new(data)
+        assert_instance_of klass, copy
+        assert_equal data, copy.to_h
+        assert_nil data[:part_type]
+        assert_nil data[:part_start]
+      end
+      Dir.mktmpdir('shapelib-test-') do |dir|
+        filename = File.join(dir, 'points')
+        Shapelib::ShapeFile.new(filename, klass, [['name', Shapelib::String, 10]]) do |file|
+          file.write(shapes.first)
+        end
+        Shapelib::ShapeFile.open(filename) do |file|
+          data = file.read(0).to_h
+          assert_equal data, Shapelib::Shape.new(data).to_h
+        end
+      end
+    end
+  end
+
+  def test_multipoint_constructors_reject_part_labels_before_conversion
+    [Shapelib::MultiPoint, Shapelib::MultiPointM, Shapelib::MultiPointZ].each do |klass|
+      converted = false
+      number = Object.new
+      number.define_singleton_method(:to_f) { converted = true; 1.0 }
+      [:Ring, 'Ring'].each do |label|
+        [[label], [label, [number, 2]]].each do |args|
+          converted = false
+          error = assert_raise(ArgumentError) { klass.new(*args) }
+          assert_equal 'MultiPoint does not accept part type labels', error.message
+          assert_equal false, converted
+        end
+      end
+    end
+  end
+
+  def test_multipoint_nested_point_lists_and_existing_coordinate_forms
+    point_class = Struct.new(:x, :y, :m, :z)
+    [Shapelib::MultiPoint, Shapelib::MultiPointM, Shapelib::MultiPointZ].each do |klass|
+      [[[1, 2, nil, 4], [5, 6, -1, 8]],
+       [Shapelib::PointZ.new(1, 2, nil, 4), Shapelib::PointZ.new(5, 6, -1, 8)],
+       [point_class.new(1, 2, nil, 4), point_class.new(5, 6, -1, 8)]].each do |points|
+        assert_equal klass.new(*points).to_h, klass.new(points).to_h
+        assert_equal klass.new(points.first).to_h, klass.new([points.first]).to_h
+      end
+      assert_equal 0, klass.new.n_vertices
+      assert_equal klass.new([0, 0]).to_h, klass.new([]).to_h
+      assert_equal [1.0], klass.new([1, 2]).xvals
+      number = Object.new
+      number.define_singleton_method(:to_f) { 1.0 }
+      assert_equal klass.new([1, 2]).to_h, klass.new([number, 2]).to_h
+    end
+  end
+
+  def test_multipoint_snapshots_nested_lists_before_callbacks
+    [:numeric_conversion, :point_detection].each do |callback|
+      later = [5, 6, 7, 8]
+      points = [[1, 2, 3, 4], later]
+      expected = Shapelib::MultiPointZ.new(*points).to_h
+      mutate = -> { points.clear; later.clear; GC.start }
+      value = Object.new
+      if callback == :numeric_conversion
+        value.define_singleton_method(:to_f) { mutate.call; 2.0 }
+        points.first[1] = value
+      else
+        coordinates = { x: 1.0, y: 2.0, m: 3.0, z: 4.0 }
+        value.define_singleton_method(:respond_to_missing?) do |name, include_private = false|
+          mutate.call if name == :x
+          coordinates.key?(name)
+        end
+        value.define_singleton_method(:method_missing) { |name, *args| coordinates.fetch(name) }
+        points[0] = value
+      end
+      assert_equal expected, Shapelib::MultiPointZ.new(points).to_h
+      assert_empty points
+      assert_empty later
+    end
+  end
+
+  def test_open_coerces_both_arguments_before_using_string_storage
+    fixture = 'test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA'
+    [:filename, :mode].each do |mutation|
+      filename = fixture.dup
+      mode = mutation == :filename ? 'rb' + ' ' * 10000 : 'rb'
+      calls = Hash.new(0)
+      name_arg = Object.new
+      name_arg.define_singleton_method(:to_str) do
+        calls[:filename] += 1
+        mode.replace('rb') if mutation == :filename
+        filename
+      end
+      mode_arg = Object.new
+      mode_arg.define_singleton_method(:to_str) do
+        calls[:mode] += 1
+        filename.replace("#{fixture}.shp") if mutation == :mode
+        mode
+      end
+      Shapelib::ShapeFile.open(name_arg, mode_arg) do |file|
+        assert_equal :Polygon, file.shape_type
+        assert_equal 0, file.read(0).shape_id
+      end
+      assert_equal({ filename: 1, mode: 1 }, calls)
+    end
+  end
+
+  def test_open_rejects_nul_introduced_by_argument_conversion
+    fixture = 'test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA'
+    [:filename, :mode].each do |mutation|
+      filename = fixture.dup
+      mode = 'rb'.dup
+      name_arg = Object.new
+      name_arg.define_singleton_method(:to_str) do
+        mode.replace("rb\0ignored") if mutation == :filename
+        filename
+      end
+      mode_arg = Object.new
+      mode_arg.define_singleton_method(:to_str) do
+        filename.replace("#{fixture}\0ignored") if mutation == :mode
+        mode
+      end
+      yielded = false
+      assert_raise(ArgumentError) do
+        Shapelib::ShapeFile.open(name_arg, mode_arg) { yielded = true }
+      end
+      assert_false yielded
+    end
+  end
+
+  def test_open_preserves_argument_conversion_exceptions
+    fixture = 'test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA'
+    [:filename, :mode].each do |argument|
+      error = RuntimeError.new('string conversion failed')
+      value = Object.new
+      value.define_singleton_method(:to_str) { raise error }
+      args = argument == :filename ? [value, 'rb'] : [fixture, value]
+      yielded = false
+      raised = assert_raise(RuntimeError) do
+        Shapelib::ShapeFile.open(*args) { yielded = true }
+      end
+      assert_same error, raised
+      assert_false yielded
+    end
+  end
+
+  def test_open_filename_rejects_nul
+    filename = "test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA\0ignored"
+    assert_raise(ArgumentError) { Shapelib::ShapeFile.open(filename) {} }
+  end
+
+  def test_new_filename_rejects_nul
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = "#{File.join(dir, 'points')}\0ignored"
+      assert_raise(ArgumentError) { Shapelib::ShapeFile.new(filename, Shapelib::Point) {} }
+      assert_empty Dir.children(dir)
+    end
+  end
+
+  def test_open_mode_rejects_nul
+    filename = 'test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA'
+    assert_raise(ArgumentError) { Shapelib::ShapeFile.open(filename, "rb\0ignored") {} }
+  end
+
+  def test_field_creation_rejects_nul
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      Shapelib::ShapeFile.new(File.join(dir, 'points'), Shapelib::Point) do |file|
+        assert_raise(ArgumentError) { file.add_field("name\0ignored", Shapelib::String, 10) }
+        assert_equal 0, file.field_count
+      end
+    end
+  end
+
+  def test_field_lookup_rejects_nul
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      Shapelib::ShapeFile.new(File.join(dir, 'points'), Shapelib::Point) do |file|
+        file.add_field('name', Shapelib::String, 10)
+        assert_equal 0, file.field_index('name')
+        assert_raise(ArgumentError) { file.field_index("name\0ignored") }
+      end
+    end
+  end
+
+  def test_field_metadata_rejects_invalid_lookups_without_reusing_values
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      fields = [['name', Shapelib::String, 10], ['amount', Shapelib::Float, 12, 3]]
+      Shapelib::ShapeFile.new(File.join(dir, 'points'), Shapelib::Point, fields) do |file|
+        fields.each_with_index do |(name, type, width, decimals), index|
+          assert_equal name, file.field_name(index)
+          assert_equal width, file.field_width(index)
+          assert_equal decimals || 0, file.field_decimals(index)
+          [-1, fields.length, 999].each do |invalid|
+            assert_nil file.field_name(invalid)
+            assert_equal(-1, file.field_width(invalid))
+            assert_equal(-1, file.field_decimals(invalid))
+          end
+          assert_equal(-1, file.field_width('missing'))
+          assert_equal(-1, file.field_decimals('missing'))
+          assert_equal name, file.field_name(index)
+          assert_equal width, file.field_width(name)
+          assert_equal decimals || 0, file.field_decimals(name)
+        end
+      end
+    end
+  end
+
+  def test_unavailable_dbf_metadata_keeps_failure_results
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      filename = File.join(dir, 'points')
+      file = Shapelib::ShapeFile.new(filename, Shapelib::Point, [['name', Shapelib::String, 10]])
+      assert_equal 'name', file.field_name(0)
+      file.close
+      assert_nil file.field_name(0)
+      assert_equal(-1, file.field_width(0))
+      assert_equal(-1, file.field_decimals(0))
+      File.unlink("#{filename}.dbf")
+      Shapelib::ShapeFile.open(filename) do |geometry|
+        assert_nil geometry.field_name(0)
+        assert_equal(-1, geometry.field_width(0))
+        assert_equal(-1, geometry.field_decimals(0))
+      end
+    ensure
+      file.close if file
+    end
+  end
+
+  def test_point_attributes_snapshot_pairs_before_name_conversion
+    [[Shapelib::Point, [1, 2]], [Shapelib::PointM, [1, 2, 3]],
+     [Shapelib::PointZ, [1, 2, 3, 4]]].each do |klass, args|
+      [:clear, :grow].each do |mutation|
+        later = ['second', 2]
+        pairs = []
+        name = Object.new
+        name.define_singleton_method(:to_str) do
+          later.replace(['changed', 99])
+          mutation == :clear ? pairs.clear : pairs.concat(Array.new(1000) { ['extra', 5] })
+          GC.start
+          'first'
+        end
+        pairs.replace([[name, 1], later, ['third', 3], ['fourth', 4]])
+        attributes = Class.new(Hash) { define_method(:to_a) { pairs } }.new
+        point = klass.new(*args, attributes)
+        assert_equal({ 'first' => 1, 'second' => 2, 'third' => 3, 'fourth' => 4 },
+                     point.to_h.select { |key, _| key.is_a?(String) })
+        assert_equal ['changed', 99], later
+        assert_equal mutation == :clear ? 0 : 1004, pairs.length
+      end
+    end
+  end
+
+  def test_point_attributes_reject_malformed_pairs
+    [[Shapelib::Point, [1, 2]], [Shapelib::PointM, [1, 2, 3]],
+     [Shapelib::PointZ, [1, 2, 3, 4]]].each do |klass, args|
+      [[], ['name'], ['name', 1, 2], nil, 'not a pair'].each do |pair|
+        attributes = Class.new(Hash) { define_method(:to_a) { [pair] } }.new
+        error_class = pair.is_a?(Array) ? ArgumentError : TypeError
+        assert_raise(error_class) { klass.new(*args, attributes) }
+      end
+      attributes = Class.new(Hash) { def to_a; nil; end }.new
+      assert_raise(TypeError) { klass.new(*args, attributes) }
+    end
+  end
+
+  def test_point_attributes_preserve_name_conversion_exceptions
+    [[Shapelib::Point, [1, 2]], [Shapelib::PointM, [1, 2, 3]],
+     [Shapelib::PointZ, [1, 2, 3, 4]]].each do |klass, args|
+      error = RuntimeError.new('name conversion failed')
+      name = Object.new
+      name.define_singleton_method(:to_str) { GC.start; raise error }
+      attributes = { name => 1 }
+      assert_same error, assert_raise(RuntimeError) { klass.new(*args, attributes) }
+    end
+  end
+
+  def test_attribute_lookup_rejects_nul
+    point = Shapelib::Point.new(1, 2)
+    point['name'] = 42
+    assert_raise(ArgumentError) { point["name\0ignored"] }
+  end
+
+  def test_attribute_assignment_rejects_nul
+    point = Shapelib::Point.new(1, 2)
+    point['name'] = 42
+    assert_raise(ArgumentError) { point["name\0ignored"] = 43 }
+    assert_equal 42, point['name']
+  end
+
+  def test_attribute_value_rejects_nul_without_changing_previous_value
+    [42, 'before'].each do |value|
+      point = Shapelib::Point.new(1, 2)
+      point['name'] = value
+      assert_raise(ArgumentError) { point['name'] = "after\0ignored" }
+      assert_equal value, point['name']
+    end
+  end
+
+  def test_frozen_shapes_reject_attribute_assignment_without_mutation
+    shapes = [Shapelib::Point.new(1, 2)]
+    Shapelib::ShapeFile.open('test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA') do |file|
+      shapes << file.read(0)
+    end
+    shapes.each do |shape|
+      shape['name'] = 'before'
+      before = shape.to_h
+      shape.freeze
+      [['name', 'after'], ['name', nil], ['extra', 42]].each do |name, value|
+        assert_raise(FrozenError) { shape[name] = value }
+        assert_equal before, shape.to_h
+      end
+      converted = false
+      name = Object.new
+      name.define_singleton_method(:to_str) { converted = true; 'name' }
+      assert_raise(FrozenError) { shape[name] = 'after' }
+      assert_false converted
+      assert_equal before, shape.to_h
+    end
+  end
+
+  def test_attribute_name_conversion_cannot_modify_a_shape_it_freezes
+    shapes = [Shapelib::Point.new(1, 2)]
+    Shapelib::ShapeFile.open('test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA') do |file|
+      shapes << file.read(0)
+    end
+    shapes.each do |shape|
+      shape['name'] = 'before'
+      before = shape.to_h
+      name = Object.new
+      name.define_singleton_method(:to_str) { shape.freeze; 'name' }
+      assert_raise(FrozenError) { shape[name] = 'after' }
+      assert_true shape.frozen?
+      assert_equal before, shape.to_h
+    end
+  end
+
+  def test_attribute_replacement_between_supported_types
+    values = [42, 1.5, 'before', nil]
+    values.product(values).each do |before, after|
+      point = Shapelib::Point.new(1, 2)
+      point['name'] = before
+      assert_same point, point.send(:[]=, 'name', after)
+      assert_equal after, point['name']
+      assert_equal !after.nil?, point.to_h.key?('name')
+    end
+    point = nil
+    GC.start
+  end
+
+  def test_cleared_attribute_slot_can_be_reused
+    [42, 1.5, 'before', nil].each do |value|
+      point = Shapelib::Point.new(1, 2)
+      point['old'] = value
+      point['old'] = nil
+      point['new'] = 'after'
+      assert_nil point['old']
+      assert_equal 'after', point['new']
+      assert_equal ['new'], point.to_h.keys.grep(String)
+    end
+    point = nil
+    GC.start
+  end
+
+  def test_invalid_attribute_replacement_preserves_previous_value
+    [42, 1.5, 'before', nil].each do |value|
+      point = Shapelib::Point.new(1, 2)
+      point['name'] = value
+      assert_raise(TypeError) { point['name'] = Object.new }
+      assert_equal value, point['name']
+      assert_raise(ArgumentError) { point['name'] = "after\0ignored" }
+      assert_equal value, point['name']
+      if 0.size > 4
+        assert_raise(RangeError) { point['name'] = 2**31 }
+        assert_equal value, point['name']
+      end
+    end
+    point = nil
+    GC.start
+  end
+
+  def test_replacing_attributes_read_from_file
+    fixture = 'test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA'
+    Shapelib::ShapeFile.open(fixture) do |file|
+      shape = file.read(0)
+      names = shape.to_h.select { |key, value| key.is_a?(String) && value.is_a?(String) }.keys
+      assert_not_empty names
+      names.each do |name|
+        shape[name] = 'replacement'
+        assert_equal 'replacement', shape[name]
+        shape[name] = nil
+        assert_nil shape[name]
+        assert_false shape.to_h.key?(name)
+      end
+      shape = nil
+      GC.start
+    end
+  end
+
+  def test_attribute_name_boundaries
+    point = Shapelib::Point.new(1, 2)
+    ['a' * 10, 'b' * 11].each do |name|
+      point[name] = 42
+      assert_equal 42, point[name]
+      assert_equal 42, point.to_h[name]
+    end
+  end
+
+  def test_long_attribute_names_are_truncated
+    name = 'long_attribute_name' * 8
+    prefix = name[0, 11]
+    [0, 16].each do |count|
+      point = Shapelib::Point.new(1, 2)
+      count.times { |i| point["field#{i}"] = i + 1 }
+      point[name] = 42
+      assert_equal 42, point[name]
+      assert_equal 42, point[prefix]
+      assert_equal 42, point[prefix.upcase]
+      assert_equal 42, point.to_h[prefix]
+      assert_equal count + 1, point.to_h.keys.grep(String).size
+      point["#{prefix}_other"] = 43
+      assert_equal 43, point[name]
+      assert_equal count + 1, point.to_h.keys.grep(String).size
+      count.times { |i| assert_equal i + 1, point["field#{i}"] }
+    end
+  end
+
+  def test_point_z_coordinate
+    point = Shapelib::PointZ.new(1, 2, 3, 4)
+    assert_equal 3.0, point.m
+    assert_equal 4.0, point.z
+  end
+
+  def test_open_block_closes_file
+    assert_block_closes_file do |block|
+      Shapelib::ShapeFile.open('test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA', &block)
+    end
+  end
+
+  def test_new_block_closes_file
+    Dir.mktmpdir('shapelib-test-') do |dir|
+      assert_block_closes_file do |block|
+        Shapelib::ShapeFile.new(File.join(dir, 'points'), Shapelib::Point, &block)
+      end
+    end
+  end
+  
+  def test_file_loading
+    filename = "test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA"
+    file = Shapelib::ShapeFile.open(filename)
+    
+    assert_equal 948, file.size
+    file.each do |shape|
+      p shape
+    end
+  ensure
+    file.close if file
+  end
+
+  private
+
+  def measure_cases
+    [[-1.0, -1.0], [0.0, 0.0], [1.0, 1.0], [-1e38, -1e38],
+     [(-1e38).prev_float, nil], [-2e38, nil], [nil, nil],
+     [-2e-38, nil], [-1.5e-38, -1.5e-38], [-3e-38, -3e-38]]
+  end
+
+  def assert_file_operation_failure(operation, filename)
+    yielded = false
+    error = assert_raise(IOError) { yield proc { yielded = true } }
+    assert_false yielded
+    assert_match(/#{Regexp.escape(operation)}/, error.message)
+    assert_match(/#{Regexp.escape(filename)}/, error.message)
+  end
+
+  def empty_geometry(type)
+    { shape_type: type, n_vertices: 0, n_parts: 0, part_type: [], part_start: [],
+      xvals: [], yvals: [], zvals: [], mvals: [] }
+  end
+
+  def hash_geometry
+    Shapelib::ArcZ.new([[0, 1, 2, 3], [4, 5, 6, 7]],
+                      [[8, 9, 10, 11], [12, 13, 14, 15]]).to_h
+  end
+
+  def assert_block_closes_file
+    [nil, RuntimeError.new('block failure')].each do |error|
+      file = nil
+      block = proc do |opened|
+        file = opened
+        assert_operator file.field_count, :>=, 0
+        raise error if error
+        :ignored
+      end
+      if error
+        assert_same error, assert_raise(RuntimeError) { yield block }
+      else
+        assert_nil yield(block)
+      end
+      assert_equal(-1, file.field_count)
+    ensure
+      file.close if file
+    end
+  end
+end