shapelib 0.7.0 → 0.8.0

metadata

@@ -1,48 +1,58 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: shapelib
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 7
-  - 0
-  version: 0.7.0
+version: !ruby/object:Gem::Version
+  version: 0.8.0
 platform: ruby
-authors: 
+authors:
 - prasinos@users.sourceforge.net
 - Mike Mangino
 - Mike Perham
-autorequire: 
+- Nick Estes
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2010-07-09 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rake-compiler
+date: 2026-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 7
-        - 0
-        version: 0.7.0
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Simple wrapper around the shapelib library
-email: mmangino@elevatedrails.com
+email: nick@nickstoys.com
 executables: []
-
-extensions: 
+extensions:
 - ext/shapelib_ext/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
-files: 
+files:
+- LICENSE
+- LICENSE-CC-BY-SA-3.0
+- LICENSE-LGPL
+- LICENSE-MIT
 - README.md
 - Rakefile
 - doc/Interface.html
@@ -62,42 +72,37 @@ files:
 - lib/shapelib.rb
 - lib/shapelib/shape.rb
 - lib/shapelib/version.rb
-- test/libtest.rb
-- test/zsample1.rb
-- test/ztest1.rb
-has_rdoc: true
-homepage: http://github.com/mperham/shapelib
-licenses: []
-
-post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+- shapelib.gemspec
+- test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA.dbf
+- test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA.prj
+- test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA.shp
+- test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA.shp.xml
+- test/data/ZillowNeighborhoods-CA/ZillowNeighborhoods-CA.shx
+- test/test_zillow_data.rb
+homepage: https://github.com/gravatite/shapelib
+licenses:
+- MIT
+- LGPL-2.0-only
+- CC-BY-SA-3.0
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.7
-signing_key: 
-specification_version: 3
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
 summary: Simple wrapper around the shapelib library
-test_files: 
-- test/libtest.rb
-- test/zsample1.rb
-- test/ztest1.rb
+test_files: []

data/test/libtest.rb

@@ -1,80 +0,0 @@
-class AssertFail < Exception
-end
-
-def assert(a, b)
-    caller = ""
-    begin
-	raise "no problem"
-    rescue RuntimeError => e
-	caller = e.backtrace[1]
-    end
-    if (b === a) then
-	val = b.inspect
-	val = "#{val}..." if val.size > 40
-	print "ok #{caller}: #{val}\n" if $VERBOSE
-    else
-	val = a.inspect
-	val = "#{val}..." if val.size > 200
-	raise AssertFail, val
-    end
-end
-
-def file_delete(*args)
-    for file in args
-	next unless File.exist?(file)
-	File.delete(file)
-    end
-end
-
-def fold_line(line)
-    buf = ""
-    while line
-	head = line[0..63]
-	buf << (head + "\n")
-	line = line[64..-1]
-    end
-    buf
-end
-
-def assert_file(filename, pat)
-    f = File.read(filename)
-    r = [pat.gsub(/\s+/, "")].pack('H*')
-
-    if (r === f) then
-	print "ok <#{filename}>\n" if $VERBOSE
-    else
-	for i in 0...(f.size)
-	    next if (f[i] == r[i])
-	    printf "ofs=%08x file=%02x expected=%02x\n", i, f[i], r[i]
-	    break
-	end
-	print "#{filename} is longer than expected\n" if f.size > r.size
-	h = f.unpack('H*').first
-	File.open("#{filename}.hex", "w") { |fp| fp.write(fold_line(h)) }
-	print "hex dump of <#{filename}> is saved to <#{filename}.hex>.\n"
-	raise AssertFail
-    end
-end
-
-def testblock(title)
-    begin
-	yield
-    rescue Exception => e
-	print "#{title} failed: #{e.message} (#{e.class.to_s})\n"
-	print "| ", e.backtrace[1..-1].join("\n| "), "\n"
-	return 1
-    else
-	print "#{title} ok\n"
-	return 0
-    end
-end
-
-def tainttest(msg)
-    begin
-	yield
-    rescue SecurityError => e
-	assert(e.message, msg)
-    else
-	raise SecurityError, "<#{msg}> doesn't come" if $SAFE > 0
-    end
-end

data/test/zsample1.rb

@@ -1,168 +0,0 @@
-require 'shapelib'
-
-class Sample1
-    include ShapeLib
-    
-    def initialize
-    end
-
-    def layer1
-	fp = ShapeFile.new('ts1stn.shp', :Point)
-	fp.add_field 'name', :String, 24
-	fp.add_field 'wdir', :String, 6 # 4
-	fp.add_field 'wspd', :Integer, 6 # 2
-	fp.add_field 'weather', :String, 16
-	fp.add_field 'pres', :Integer, 6 # 4
-	fp.add_field 'temp', :Integer, 6 # 3
-	fp.write new_point(124.17, 24.33,
-	    'name' => 'Ishigakijima', 'wdir' => 'S', 'wspd' => 3,
-	    'weather' => 'shower', 'pres' => 1014, 'temp' => 24)
-	csv = <<EOF
-127:41.1, 26:12.4, Naha, S, 4, partly cloudy, 1015, 21
-131.23, 25.83, Minamidaito Jima, SSW, 2, partly cloudy, 1017, 20
-129:29.7, 28:22.7, Naze, SW, 2, partly cloudy, 1017, 20
-130.72, 31.80, Kagoshima, WSW, 1, shower, 1013, 18
-128:49.6, 32:41.6, Fukue, NNE, 3, cloudy, 1014, 11
-129:17.5, 34:11.8, Izuhara, NNW, 2, cloudy, 1016, 10
-133:00.6, 32:43.3, Ashizuri Misaki, W, 2, cloudy, 1011, 17
-134:10.6, 33:15.1, Muroto Misaki, NNE, 3, fog, 1012, 13
-132:46.6, 33:50.6, Matsuyama, SE, 1, rain, 1014, 10
-132:04.2, 34:53.8, Hamada, ENE, 1, cloudy, 1015, 8
-133.3, 36.2, Saigo, NNE, 2, shower, 1016, 7
-135.6, 34.7, Osaka, NNE, 2, cloudy, 1014, 9
-135:45.6, 33:27.0, Shio no Misaki, NE, 1, shower, 1012, 13
-139.8, 33.1, Hachijo Jima, SW, 4, shower, 1013, 18
-139.4, 34.8, Izu Oshima, NNE, 4, shower, 1014, 9
-138:12.7, 34:36.2, Omaezaki, NE, 2, rain, 1012, 12
-140:51.4, 35:44.3, Choshi, NNE, 5, rain, 1014, 7
-139:03.6, 36:24.3, Maebashi, WNW, 1, rain, 1015, 8
-140:54.2, 36:56.8, Onahama, N, 3, rain, 1017, 5
-136:53.7, 37:23.5, Wajima, ENE, 1, rain, 1016, 5
-138:14.3, 38:01.7, Aikawa, SE, 2, rain, 1016, 4
-140.9, 38.2, Sendai, NNW, 1, snow-rain, 1018, 1
-141:57.9, 39:38.8, Miyako, N, 2, snow, 1020, 1
-140.2, 39.6, Akita, NNE, 1, cloudy, 1018, 0
-140.8, 41.8, Hakodate, NNE, 3, cloudy, 1019, -4
-142:46.6, 42:09.7, Urakawa, NNE, 2, cloudy, 1019, -5
-145:35.1, 43:19.8, Nemuro, CALM, 0, cloudy, 1019, -5
-141:40.7, 45:24.9, Wakkanai, W, 3, cloudy, 1018, -4
-151, 46, Poronaisk, W, 3, cloudy, 1018, -4
-156, 50, Severo-Kurilsk, WSW, 3, partly cloudy, 1014, -16
-135.17, 48.52, Habarovsk, CALM, 0, partly cloudy, 1014, -19
-135:48, 44:21, Rudnaya Pristan, W, 1, cloudy, 1019, -13
-131.93, 43.12, Vladivostok, SE, 3, cloudy, 1018, -5
-126.97, 37.57, Seoul, NNE, 1, partly cloudy, 1019, 1
-131, 37, Ulleung-do, NE, 1, cloudy, 1018, 3
-128.93, 35.18, Pusan, NNE, 3, cloudy, 1016, 6
-127, 35, Mokpo, NNE, 3, cloudy, 1019, 3
-126.50, 33.50, Cheju-do, NNE, 1, cloudy, 1017, 9
-121.55, 25.07, Taipei, ESE, 1, cloudy, 1013, 21
-120.35, 22.58, Kaohsiung, N, 1, cloudy, 1013, 24
-125.22, 43.90, Changchun, WNW, 3, clear, 1024, -13
-116.28, 39.93, Beijing, NNW, 4, partly cloudy, 1031, -2
-121.63, 38.90, Dalian, NNW, 3, partly cloudy, 1024, -1
-120.33, 36.07, Qingdao, NNW, 4, fog, 1024, 2
-121.4, 31.2, Shanghai, N, 3, rain, 1021, 7
-114.13, 30.62, Wuhan, NNW, 2, rain, 1025, 8
-118.08, 24.48, Xiamen, CALM, 0, fog, 1014, 18
-114.02, 22.20, Hong Kong, ESE, 2, partly cloudy, 1014, 21
-120.53, 18.18, Laoag, CALM, 0, clear, 1012, 22
-121.00, 14.52, Manila, WNW, 1, partly cloudy, 1013, 25
-142.18, 27.08, Chichi Jima, NW, 1, clear, 1020, 16
-133.97, 24.30, Minami Tori Shima, E, 4, X, 1021, 23
-138:43.6, 35:21.6, Fujisan, X, X, X, X, -4
-126, 29, SHIP,  NW, 5, rain, 1015, X
-148, 21, SHIP,   E, 3, cloudy, 1018, X
-139, 31, SHIP,  SW, 7, partly cloudy, 1016, X
-136, 39, SHIP, ENE, 5, partly cloudy, 1017, X
-146, 36, SHIP, ENE, 5, rain, 1013, X
-EOF
-	for line in csv.split(/\n/)
-	    x, y, name, wdir, wspd, weather, pres, temp = line.split(/, */)
-	    x = $1.to_i + $2.to_f / 60 if /(\d+):(\d+(\.\d)?)/ === x
-	    y = $1.to_i + $2.to_f / 60 if /(\d+):(\d+(\.\d)?)/ === y
-	    x = Float(x)
-	    y = Float(y)
-	    wdir = nil if wdir == 'X'
-	    weather = nil if weather == 'X'
-	    wspd = (wspd == 'X' ? nil : Integer(wspd))
-	    pres = (pres == 'X' ? nil : Integer(pres))
-	    temp = (temp == 'X' ? nil : Integer(temp))
-	    fp.write new_point(x, y,
-		'name' => name, 'wdir' => wdir, 'wspd' => wspd,
-		'weather' => weather , 'pres' => pres, 'temp' => temp)
-	end
-	fp.close
-    end
-
-    def layer2
-	fp = ShapeFile.new('ts1sys.shp', :Point)
-	fp.add_field 'class', 'String', 16
-	fp.add_field 'symbol', 'String', 3
-	fp.add_field 'pres', 'Integer', 4
-	fp.add_field 'dir', 'String', 4
-	fp.add_field 'speed', 'Integer', 3
-	fp.write new_point(169, 45, 'class' => 'Low', 'symbol' => 'L',
-	    'pres' => 992, 'dir' => 'NNE', 'speed' => 20)
-	fp.write new_point(177, 58, 'class' => 'Low', 'symbol' => 'L',
-	    'pres' => 996, 'dir' => 'N', 'speed' => 10)
-	fp.write new_point(130, 41, 'class' => 'Low', 'symbol' => 'L',
-	    'pres' => 1016, 'dir' => 'ENE', 'speed' => 10)
-	fp.write new_point(134, 33, 'class' => 'Low', 'symbol' => 'L',
-	    'pres' => 1012, 'dir' => 'ENE', 'speed' => 20)
-	fp.write new_point(152, 57, 'class' => 'Low', 'symbol' => 'L',
-	    'pres' => 1000, 'dir' => 'WSW', 'speed' => 5)
-	fp.write new_point(156, 48, 'class' => 'Low', 'symbol' => 'L',
-	    'pres' => 1004, 'dir' => 'E', 'speed' => 10)
-	fp.write new_point(139,  3, 'class' => 'Low', 'symbol' => 'L',
-	    'pres' => 1008, 'dir' => 'STNR', 'speed' => 0)
-	fp.write new_point(138, 43, 'class' => 'High', 'symbol' => 'H',
-	    'pres' => 1020, 'dir' => 'E', 'speed' => 15)
-	fp.write new_point(164, 29, 'class' => 'High', 'symbol' => 'H',
-	    'pres' => 1024, 'dir' => 'E', 'speed' => 20)
-	fp.close
-    end
-
-    def layer3
-	fp = ShapeFile.new('ts1frnt.shp', :Arc)
-	fp.add_field 'class', 'String', 16
-
-	arc = Arc.new [[169, 45], [172, 44], [175, 41]]
-	arc['class'] = 'occlusion'
-	fp.write arc
-
-	arc = Arc.new [[175, 41], [177, 39], [178, 37]]
-	arc['class'] = 'warm'
-	fp.write arc
-
-	arc = Arc.new [[175, 41], [171, 38], [164, 36]]
-	arc['class'] = 'cold'
-	fp.write arc
-
-	arc = Arc.new [[119, 27], [128, 29], [134, 33], [139, 34],
-	    [142, 35], [150, 35]]
-	arc['class'] = 'stationary'
-	fp.write arc
-
-	fp.close
-    end
-
-    def layer4
-	fp = ShapeFile.new('ts1isop.shp', :Arc)
-	fp.add_field 'pres', 'Integer', 4
-	arc = Arc.new [[168, 19], [150, 18], [141, 19], [129, 22], [133, 29], [147, 34], [149, 36], [141, 37], [128, 34], [122, 28], [110, 25]]
-	arc['pres'] = 1016
-	fp.write arc
-	fp.close
-    end
-
-    def run
-	layer1
-	layer2
-	layer3
-	layer4
-    end
-
-end
-
-Sample1.new.run

data/test/ztest1.rb

@@ -1,253 +0,0 @@
-require 'shapelib'
-require 'libtest.rb'
-
-def test1
-    testblock('test1') do 
-	file_delete(*%w(test1.dbf test1.shp test1.shx))
-	s = ShapeLib::ShapeFile.new('test1.shp', :Point, [["id", :Integer, 8]])
-	assert(s.field_count, 1)
-	s.add_field 'name', ShapeLib::String, 12
-	assert(s.field_count, 2)
-	assert(s.field_index('name'), 1)
-	assert(s.field_type('name'), :String)
-	assert(s.field_type(1), :String)
-	s.add_field 'k', ShapeLib::Integer, 3
-	assert(s.field_count, 3)
-	s.add_field 'y', "Float", 8, 3
-	assert(s.field_index('y'), 3)
-	assert(s.field_type('y'), :Float)
-	assert(s.field_count, 4)
-	assert(s.size, 0)
-
-	shape = ShapeLib::Point.new(100, 101, 'id' => 234)
-	shape['name'] = 'foo'
-	shape['k'] = 18
-	fval = shape['y'] = 31.415926
-	assert(s.write(shape), 0)
-	assert(s.size, 1)
-	assert(shape.x, 100.0)
-
-	assert(s.fields, %w(id name k y))
-	assert(s.field_type(1), :String)
-	assert(s.field_name(1), 'name')
-
-	assert(shape['id'], 234)
-	assert(shape['name'], 'foo')
-	assert(shape['k'], 18)
-	assert(shape['y'], fval)
-	assert(shape['unspecified'], nil)
-
-	shape = ShapeLib.new_point(200, 201)
-	assert(s.write(shape), 1)
-	assert(s.size, 2)
-
-	assert(shape['id'], nil)
-	assert(shape.x, 200.0)
-
-	shape = s.read(0)
-	assert(shape.shape_id, 0)
-	assert(shape['id'], 234)
-	assert(shape['name'], 'foo')
-	assert(shape['k'], 18)
-	# note that only 3 digits after decimal point is conserved.
-	assert(shape['y'], 31.416)
-	assert(shape['unspecified'], nil)
-	assert(shape['unspecified2'], nil)
-
-	assert s.maxbound, [200, 201, 0, 0]
-
-	s.close
-
-	assert_file 'test1.dbf', <<EOF
-035f071a02000000a10020000000000000000000000000000000000000000000
-69640000000000000000004e0000000008000000000000000000000000000000
-6e616d650000000000000043000000000c000000000000000000000000000000
-6b000000000000000000004e0000000003000000000000000000000000000000
-79000000000000000000004e0000000008030000000000000000000000000000
-0d202020202020323334666f6f202020202020202020203138202033312e3431
-36202a2a2a2a2a2a2a2a0000000000000000000000002a2a2a2a2a2a2a2a2a2a
-2a
-EOF
-	assert_file 'test1.shp', <<EOF
-0000270a00000000000000000000000000000000000000000000004ee8030000
-0100000000000000000059400000000000405940000000000000694000000000
-0020694000000000000000000000000000000000000000000000000000000000
-00000000000000010000000a0100000000000000000059400000000000405940
-000000020000000a0100000000000000000069400000000000206940
-EOF
-	assert_file 'test1.shx', <<EOF
-0000270a00000000000000000000000000000000000000000000003ae8030000
-0100000000000000000059400000000000405940000000000000694000000000
-0020694000000000000000000000000000000000000000000000000000000000
-00000000000000320000000a000000400000000a
-EOF
-
-	file_delete(*%w(test1.dbf test1.shp test1.shx))
-    end
-end
-
-def test2
-    testblock('test2') do 
-	file_delete(*%w(test2.dbf test2.shp test2.shx))
-	s = ShapeLib::ShapeFile.new('test2.shp', ShapeLib::PointM)
-	assert(s.class.to_s, "ShapeLib::ShapeFile")
-	assert(s.field_count, 0)
-	s.add_field 'name', ShapeLib::String, 12
-	assert(s.field_count, 1)
-	assert(s.size, 0)
-
-	shape = ShapeLib.new_point(301, 302, 303)
-	assert(shape.class.to_s, "ShapeLib::PointM")
-	s.write(shape)
-	assert(s.size, 1)
-	assert(shape.m, 303)
-
-	shape = ShapeLib::PointM.new(401, 402, 403)
-	assert(shape.class.to_s, "ShapeLib::PointM")
-	s.write(shape)
-	assert(s.size, 2)
-
-	s.close
-	assert_file 'test2.shp', <<EOF
-0000270a000000000000000000000000000000000000000000000056e8030000
-150000000000000000d072400000000000e07240000000000010794000000000
-00207940000000000000000000000000000000000000000000f0724000000000
-00307940000000010000000e150000000000000000d072400000000000e07240
-0000000000f07240000000020000000e15000000000000000010794000000000
-002079400000000000307940
-EOF
-
-        sx = ShapeLib::ShapeFile.open('test2.shp')
-	assert sx.shape_type, :PointM
-	assert sx.minbound, [301.0, 302.0, 303.0, 0]
-	assert sx.maxbound, [401.0, 402.0, 403.0, 0]
-	sx.close
-
-	file_delete(*%w(test2.dbf test2.shp test2.shx))
-    end
-end
-
-def testA1
-    testblock('testA1') do 
-	file_delete(*%w(testa1.dbf testa1.shp testa1.shx))
-	s = ShapeLib::ShapeFile.new('testa1.shp', "Arc")
-	assert(s.class.to_s, "ShapeLib::ShapeFile")
-	assert(s.field_count, 0)
-	s.add_field 'name', ShapeLib::String, 12
-	assert(s.field_count, 1)
-	assert(s.size, 0)
-	
-	p1 = ShapeLib.new_point(1.1, 1.2)
-	p2 = ShapeLib.new_point(2.1, 2.2)
-	p3 = ShapeLib.new_point(3.1, 3.2)
-	shape = ShapeLib::Arc.new([p1, p2, p3])
-	assert(shape.class.to_s, 'ShapeLib::Arc')
-	assert(shape.n_parts, 1)
-	assert(shape.n_vertices, 3)
-	assert(shape.shape_id, nil)
-	assert(shape.shape_type, :Arc)
-	assert(s.write(shape), 0)
-
-	arc2 = [[101, 102], [111, 112], [121, 122]]
-	shape = ShapeLib::Arc.new([p1, p3], arc2)
-	assert(shape.n_parts, 2)
-	assert(s.write(shape), 1)
-
-	assert(shape.shape_id, nil)
-	assert(s.read(1).shape_id, 1)
-
-	file_delete(*%w(testa1.dbf testa1.shp testa1.shx))
-    end
-end
-
-def test3
-    testblock('test3') do
-	pt = ShapeLib::Point.new 4324434.13545, 3495423412.4324324
-	assert(pt.wkt, "POINT(4324434.135 3495423412)")
-	assert(pt.part_type, nil)
-	mp = ShapeLib::MultiPoint.new [1, 2], [3, 4], [5, 6]
-	assert(mp.wkt, "MULTIPOINT(1 2, 3 4, 5 6)")
-
-	ar = ShapeLib::Arc.new [1, 2], [3, 4], [5, 6]
-	assert(ar.wkt, "LINESTRING(1 2, 3 4, 5 6)")
-	assert(ar.xvals, [1, 3, 5])
-	assert(ar.yvals, [2, 4, 6])
-	ar = ShapeLib::Arc.new([[1, 2], [3, 4], [5, 6]])
-	assert(ar.wkt, "LINESTRING(1 2, 3 4, 5 6)")
-	ar = ShapeLib::Arc.new([[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10]])
-	assert(ar.wkt, "MULTILINESTRING((1 2, 3 4, 5 6), (7 8, 9 10))")
-	assert ar.xvals, [1, 3, 5, 7, 9]
-
-	ar2 = ShapeLib::Shape.new(arh = ar.to_h)
-	assert(ar2.class.to_s, "ShapeLib::Arc")
-	assert(ar2.to_h, arh)
-	assert(ar2.wkt, ar.wkt)
-
-	arm = ShapeLib::ArcM.new [1, 2, 3], [4, 5, 6], [7, 8, 9]
-	assert arm.mvals, [3, 6, 9]
-	arm = ShapeLib::ArcM.new [1, 2], [4, 5], [7, 8]
-	assert arm.mvals, [nil, nil, nil]
-
-	pl = ShapeLib::Polygon.new [1, 2], [3, 4], [5, 6.5], [1, 2]
-	assert(pl.wkt, "POLYGON((1 2, 3 4, 5 6.5, 1 2))")
-	assert(pl.rewind_polygon, true)
-	assert(pl.wkt, "POLYGON((1 2, 5 6.5, 3 4, 1 2))")
-	pl = ShapeLib::Polygon.new [[1, 2], [3, 4], [5, 6.5], [1, 2]]
-	assert(pl.wkt, "POLYGON((1 2, 3 4, 5 6.5, 1 2))")
-	pl = ShapeLib::Polygon.new([[1, 2], [3, 4], [5, 6.5], [1, 2]],
-	    [[7, 8], [9, 10], [11, 12.5], [7, 8]])
-	assert(pl.part_type, [:Ring, :Ring])
-	assert(pl.wkt,
-	    "POLYGON((1 2, 3 4, 5 6.5, 1 2), (7 8, 9 10, 11 12.5, 7 8))")
-
-	pl['abbrev'] = 'WI'
-	pl['state'] = 'Wisconsin'
-	pl['update'] = '2006-02-16'
-	assert ShapeLib::Shape.new(pl.to_h).to_h, pl.to_h
-
-	mq = ShapeLib::MultiPatch.new :OuterRing, [1, 2], [3, 4], [5, 6.5], [1, 2]
-	assert(mq.wkt, "POLYGON((1 2, 3 4, 5 6.5, 1 2))")
-    end
-end
-
-def test4
-    testblock('test4') do 
-	file_delete(*%w(test4.dbf test4.shp test4.shx))
-	s = ShapeLib::ShapeFile.new('test4.shp', :PointM)
-	assert(s.class.to_s, "ShapeLib::ShapeFile")
-	assert(s.field_count, 0)
-	assert(s.size, 0)
-	# shape = ShapeLib.new_point(301, 302, 303, 'foo' => 123)
-	shape = ShapeLib.new_point(301, 302, 303)
-	assert(s.write(shape), 0)
-	shape = ShapeLib::PointM.new(401, 402, 403)
-	assert(s.write(shape), 1)
-	s.close
-
-	fp = ShapeLib::ShapeFile.open('test4')
-	assert fp.size, 2
-	shape = fp.read(0)
-	assert(shape.class.to_s, "ShapeLib::Shape")
-	assert fp.size, 2
-	fp.close
-
-	ShapeLib::ShapeFile.open('test4.shp') do |fp|
-	    shape = fp.read
-	    assert(shape.shape_id, 0)
-	    shape = fp.read
-	    assert(shape.shape_id, 1)
-	    assert(fp.read, nil)
-	    i = 0
-	    fp.each do |shape|
-		assert shape.shape_id, i
-		i += 1
-	    end
-	    assert i, 2
-	end
-
-	file_delete(*%w(test4.dbf test4.shp test4.shx))
-    end
-end
-
-
-exit(test1 + test2 + testA1 + test3 + test4)