rgeo 0.5.3 → 0.6.0

data/test/types_test.rb

@@ -1,42 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for type properties
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    class TestTypes < ::Test::Unit::TestCase # :nodoc:
-      def test_geometry
-        assert_equal("Geometry", ::RGeo::Feature::Geometry.type_name)
-        assert_nil(::RGeo::Feature::Geometry.supertype)
-        assert(::RGeo::Feature::Geometry.subtype_of?(::RGeo::Feature::Geometry))
-        assert(!::RGeo::Feature::Geometry.subtype_of?(::RGeo::Feature::Point))
-      end
-
-      def test_point
-        assert_equal("Point", ::RGeo::Feature::Point.type_name)
-        assert_equal(::RGeo::Feature::Geometry, ::RGeo::Feature::Point.supertype)
-        assert(::RGeo::Feature::Point.subtype_of?(::RGeo::Feature::Point))
-        assert(::RGeo::Feature::Point.subtype_of?(::RGeo::Feature::Geometry))
-        assert(!::RGeo::Feature::Point.subtype_of?(::RGeo::Feature::LineString))
-      end
-
-      def test_line_string
-        assert_equal("LineString", ::RGeo::Feature::LineString.type_name)
-        assert_equal(::RGeo::Feature::Curve, ::RGeo::Feature::LineString.supertype)
-        assert(::RGeo::Feature::LineString.subtype_of?(::RGeo::Feature::LineString))
-        assert(::RGeo::Feature::LineString.subtype_of?(::RGeo::Feature::Curve))
-        assert(::RGeo::Feature::LineString.subtype_of?(::RGeo::Feature::Geometry))
-        assert(!::RGeo::Feature::LineString.subtype_of?(::RGeo::Feature::Line))
-      end
-    end
-  end
-end
-
-unless ::RGeo.yaml_supported?
-  puts "WARNING: Psych not installed. Skipping YAML tests."
-end

data/test/wkrep/wkb_generator_test.rb

@@ -1,185 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for WKT generator
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module WKRep # :nodoc:
-      class TestWKBGenerator < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Cartesian.preferred_factory(srid: 1000)
-          @factoryz = ::RGeo::Cartesian.preferred_factory(srid: 1000, has_z_coordinate: true)
-          @factorym = ::RGeo::Cartesian.preferred_factory(srid: 1000, has_m_coordinate: true)
-          @factoryzm = ::RGeo::Cartesian.preferred_factory(srid: 1000, has_z_coordinate: true, has_m_coordinate: true)
-        end
-
-        def test_point_basic_xdr
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.point(1, 2)
-          assert_equal("00000000013ff00000000000004000000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_basic_ndr
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, little_endian: true)
-          obj_ = @factory.point(1, 2)
-          assert_equal("0101000000000000000000f03f0000000000000040", generator_.generate(obj_))
-        end
-
-        def test_point_2d_ewkb
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb)
-          obj_ = @factory.point(1, 2)
-          assert_equal("00000000013ff00000000000004000000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_2d_wkb12
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :wkb12)
-          obj_ = @factory.point(1, 2)
-          assert_equal("00000000013ff00000000000004000000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_2d_ewkb_with_srid
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true)
-          obj_ = @factory.point(1, 2)
-          assert_equal("0020000001000003e83ff00000000000004000000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_with_ewkb_z
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb)
-          obj_ = @factoryz.point(1, 2, 3)
-          assert_equal("00800000013ff000000000000040000000000000004008000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_with_ewkb_m
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb)
-          obj_ = @factorym.point(1, 2, 3)
-          assert_equal("00400000013ff000000000000040000000000000004008000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_with_ewkb_zm
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb)
-          obj_ = @factoryzm.point(1, 2, 3, 4)
-          assert_equal("00c00000013ff0000000000000400000000000000040080000000000004010000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_with_wkb12_z
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :wkb12)
-          obj_ = @factoryz.point(1, 2, 3)
-          assert_equal("00000003e93ff000000000000040000000000000004008000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_with_wkb12_m
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :wkb12)
-          obj_ = @factorym.point(1, 2, 3)
-          assert_equal("00000007d13ff000000000000040000000000000004008000000000000", generator_.generate(obj_))
-        end
-
-        def test_point_with_wkb12_zm
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :wkb12)
-          obj_ = @factoryzm.point(1, 2, 3, 4)
-          assert_equal("0000000bb93ff0000000000000400000000000000040080000000000004010000000000000", generator_.generate(obj_))
-        end
-
-        def test_linestring_basic
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.line_string([@factory.point(1, 2), @factory.point(3, 4), @factory.point(5, 6)])
-          assert_equal("0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000", generator_.generate(obj_))
-        end
-
-        def test_linestring_with_ewkb_z
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb)
-          obj_ = @factoryz.line_string([@factoryz.point(1, 2, 3), @factoryz.point(4, 5, 6)])
-          assert_equal("0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000", generator_.generate(obj_))
-        end
-
-        def test_linestring_with_ewkb_z_and_srid
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true)
-          obj_ = @factoryz.line_string([@factoryz.point(1, 2, 3), @factoryz.point(4, 5, 6)])
-          assert_equal("00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000", generator_.generate(obj_))
-        end
-
-        def test_linestring_with_wkb12_m
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :wkb12)
-          obj_ = @factorym.line_string([@factorym.point(1, 2, 3), @factorym.point(4, 5, 6)])
-          assert_equal("00000007d2000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000", generator_.generate(obj_))
-        end
-
-        def test_linestring_empty
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.line_string([])
-          assert_equal("000000000200000000", generator_.generate(obj_))
-        end
-
-        def test_polygon_basic
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.polygon(@factory.linear_ring([@factory.point(1, 2), @factory.point(3, 4), @factory.point(6, 5), @factory.point(1, 2)]))
-          assert_equal("000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000", generator_.generate(obj_))
-        end
-
-        def test_polygon_empty
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.polygon(@factory.linear_ring([]))
-          assert_equal("000000000300000000", generator_.generate(obj_))
-        end
-
-        def test_multipoint_basic
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.multi_point([@factory.point(1, 2), @factory.point(3, 4)])
-          assert_equal("00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000", generator_.generate(obj_))
-        end
-
-        def test_multipoint_with_ewkb_z
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb)
-          obj_ = @factoryz.multi_point([@factoryz.point(1, 2, 5), @factoryz.point(3, 4, 6)])
-          assert_equal("00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000", generator_.generate(obj_))
-        end
-
-        def test_multipoint_empty
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.multi_point([])
-          assert_equal("000000000400000000", generator_.generate(obj_))
-        end
-
-        def test_multilinestring_basic
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.multi_line_string([@factory.line_string([@factory.point(1, 2), @factory.point(3, 4), @factory.point(5, 6)]), @factory.line_string([@factory.point(-1, -2), @factory.point(-3, -4)])])
-          assert_equal("0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000", generator_.generate(obj_))
-        end
-
-        def test_multilinestring_empty
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.multi_line_string([])
-          assert_equal("000000000500000000", generator_.generate(obj_))
-        end
-
-        def test_multipolygon_basic
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.multi_polygon([@factory.polygon(@factory.linear_ring([@factory.point(1, 2), @factory.point(3, 4), @factory.point(6, 5), @factory.point(1, 2)])), @factory.polygon(@factory.linear_ring([]))])
-          assert_equal("000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000", generator_.generate(obj_))
-        end
-
-        def test_multipolygon_empty
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.multi_polygon([])
-          assert_equal("000000000600000000", generator_.generate(obj_))
-        end
-
-        def test_collection_basic
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.collection([@factory.line_string([@factory.point(1, 2), @factory.point(3, 4), @factory.point(5, 6)]), @factory.point(-1, -2)])
-          assert_equal("0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000", generator_.generate(obj_))
-        end
-
-        def test_collection_empty
-          generator_ = ::RGeo::WKRep::WKBGenerator.new(hex_format: true)
-          obj_ = @factory.collection([])
-          assert_equal("000000000700000000", generator_.generate(obj_))
-        end
-      end
-    end
-  end
-end

data/test/wkrep/wkb_parser_test.rb

@@ -1,293 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for WKT parser
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module WKRep # :nodoc:
-      class TestWKBParser < ::Test::Unit::TestCase # :nodoc:
-        def test_point_2d_xdr_hex
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("00000000013ff00000000000004000000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(1, obj_.x)
-          assert_equal(2, obj_.y)
-        end
-
-        def test_point_2d_xdr_binary
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse(["00000000013ff00000000000004000000000000000"].pack("H*"))
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(1, obj_.x)
-          assert_equal(2, obj_.y)
-        end
-
-        def test_point_2d_ndr
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("0101000000000000000000f03f0000000000000040")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(1, obj_.x)
-          assert_equal(2, obj_.y)
-        end
-
-        def test_point_with_ewkb_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
-          obj_ = parser_.parse("00800000013ff000000000000040000000000000004008000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(3, obj_.z)
-          assert_nil(obj_.m)
-        end
-
-        def test_point_with_ewkb_m
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_m_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
-          obj_ = parser_.parse("00400000013ff000000000000040000000000000004008000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(3, obj_.m)
-          assert_nil(obj_.z)
-        end
-
-        def test_point_with_ewkb_zm
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, has_m_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
-          obj_ = parser_.parse("00c00000013ff0000000000000400000000000000040080000000000004010000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(3, obj_.z)
-          assert_equal(4, obj_.m)
-        end
-
-        def test_point_with_wkb12_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
-          obj_ = parser_.parse("00000003e93ff000000000000040000000000000004008000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(3, obj_.z)
-          assert_nil(obj_.m)
-        end
-
-        def test_point_with_wkb12_m
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_m_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
-          obj_ = parser_.parse("00000007d13ff000000000000040000000000000004008000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(3, obj_.m)
-          assert_nil(obj_.z)
-        end
-
-        def test_point_with_wkb12_zm
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, has_m_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
-          obj_ = parser_.parse("0000000bb93ff0000000000000400000000000000040080000000000004010000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(3, obj_.z)
-          assert_equal(4, obj_.m)
-        end
-
-        def test_point_with_wkb12_z_without_wkb12_support
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_)
-          assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse("00000003e93ff000000000000040000000000000004008000000000000")
-          end
-        end
-
-        def test_point_with_wkb12_z_without_enough_data
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
-          assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse("00000003e93ff00000000000004000000000000000")
-          end
-        end
-
-        def test_point_with_ewkb_z_and_srid
-          factory_generator_ = ::Proc.new do |config_|
-            ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, srid: config_[:srid])
-          end
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, support_ewkb: true)
-          obj_ = parser_.parse("00a0000001000003e83ff000000000000040000000000000004008000000000000")
-          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
-          assert_equal(3, obj_.z)
-          assert_nil(obj_.m)
-          assert_equal(1000, obj_.srid)
-        end
-
-        def test_linestring_basic
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
-          assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
-          assert_equal(3, obj_.num_points)
-          assert_equal(1, obj_.point_n(0).x)
-          assert_equal(6, obj_.point_n(2).y)
-        end
-
-        def test_linestring_with_ewkb_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
-          obj_ = parser_.parse("0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
-          assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
-          assert_equal(2, obj_.num_points)
-          assert_equal(1, obj_.point_n(0).x)
-          assert_equal(6, obj_.point_n(1).z)
-        end
-
-        def test_linestring_with_ewkb_z_and_srid
-          factory_generator_ = ::Proc.new do |config_|
-            ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, srid: config_[:srid])
-          end
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, support_ewkb: true)
-          obj_ = parser_.parse("00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
-          assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
-          assert_equal(2, obj_.num_points)
-          assert_equal(1, obj_.point_n(0).x)
-          assert_equal(6, obj_.point_n(1).z)
-          assert_equal(1000, obj_.srid)
-        end
-
-        def test_linestring_with_wkb12_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
-          obj_ = parser_.parse("00000003ea000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
-          assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
-          assert_equal(2, obj_.num_points)
-          assert_equal(1, obj_.point_n(0).x)
-          assert_equal(6, obj_.point_n(1).z)
-        end
-
-        def test_linestring_empty
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000200000000")
-          assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
-          assert_equal(0, obj_.num_points)
-        end
-
-        def test_polygon_basic
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000")
-          assert_equal(::RGeo::Feature::Polygon, obj_.geometry_type)
-          assert_equal(4, obj_.exterior_ring.num_points)
-          assert_equal(1, obj_.exterior_ring.point_n(0).x)
-          assert_equal(5, obj_.exterior_ring.point_n(2).y)
-        end
-
-        def test_polygon_empty
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000300000000")
-          assert_equal(::RGeo::Feature::Polygon, obj_.geometry_type)
-          assert_equal(0, obj_.exterior_ring.num_points)
-        end
-
-        def test_multipoint_basic
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000")
-          assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
-          assert_equal(2, obj_.num_geometries)
-          assert_equal(1, obj_[0].x)
-          assert_equal(4, obj_[1].y)
-        end
-
-        def test_multipoint_mixed_byte_order
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("0000000004000000020101000000000000000000f03f0000000000000040000000000140080000000000004010000000000000")
-          assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
-          assert_equal(2, obj_.num_geometries)
-          assert_equal(1, obj_[0].x)
-          assert_equal(4, obj_[1].y)
-        end
-
-        def test_multipoint_with_ewkb_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
-          obj_ = parser_.parse("00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000")
-          assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
-          assert_equal(2, obj_.num_geometries)
-          assert_equal(1, obj_[0].x)
-          assert_equal(5, obj_[0].z)
-          assert_equal(4, obj_[1].y)
-          assert_equal(6, obj_[1].z)
-          assert_nil(obj_[0].m)
-        end
-
-        def test_multipoint_ewkb_with_mixed_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
-          assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse("00800000040000000200800000013ff000000000000040000000000000004014000000000000000000000140080000000000004010000000000000")
-          end
-        end
-
-        def test_multipoint_empty
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000400000000")
-          assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
-          assert_equal(0, obj_.num_geometries)
-        end
-
-        def test_multilinestring_basic
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000")
-          assert_equal(::RGeo::Feature::MultiLineString, obj_.geometry_type)
-          assert_equal(2, obj_.num_geometries)
-          assert_equal(1, obj_[0].point_n(0).x)
-          assert_equal(-4, obj_[1].point_n(1).y)
-        end
-
-        def test_multilinestring_wrong_element_type
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse("0000000005000000020000000002000000033ff00000000000004000000000000000400800000000000040100000000000004014000000000000401800000000000000000000013ff00000000000004000000000000000")
-          end
-        end
-
-        def test_multilinestring_empty
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000500000000")
-          assert_equal(::RGeo::Feature::MultiLineString, obj_.geometry_type)
-          assert_equal(0, obj_.num_geometries)
-        end
-
-        def test_multipolygon_basic
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000")
-          assert_equal(::RGeo::Feature::MultiPolygon, obj_.geometry_type)
-          assert_equal(2, obj_.num_geometries)
-          assert_equal(4, obj_[0].exterior_ring.num_points)
-          assert_equal(1, obj_[0].exterior_ring.point_n(0).x)
-          assert_equal(5, obj_[0].exterior_ring.point_n(2).y)
-          assert_equal(0, obj_[1].exterior_ring.num_points)
-        end
-
-        def test_multipolygon_empty
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000600000000")
-          assert_equal(::RGeo::Feature::MultiPolygon, obj_.geometry_type)
-          assert_equal(0, obj_.num_geometries)
-        end
-
-        def test_collection_basic
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000")
-          assert_equal(::RGeo::Feature::GeometryCollection, obj_.geometry_type)
-          assert_equal(2, obj_.num_geometries)
-          assert_equal(::RGeo::Feature::LineString, obj_[0].geometry_type)
-          assert_equal(1, obj_[0].point_n(0).x)
-          assert_equal(6, obj_[0].point_n(2).y)
-          assert_equal(::RGeo::Feature::Point, obj_[1].geometry_type)
-          assert_equal(-1, obj_[1].x)
-        end
-
-        def test_collection_empty
-          parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse("000000000700000000")
-          assert_equal(::RGeo::Feature::GeometryCollection, obj_.geometry_type)
-          assert_equal(0, obj_.num_geometries)
-        end
-      end
-    end
-  end
-end