rgeo 0.5.3 → 0.6.0

data/test/common/multi_point_tests.rb

@@ -1,200 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Common tests for multi point implementations
-#
-# -----------------------------------------------------------------------------
-
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module Common # :nodoc:
-      module MultiPointTests # :nodoc:
-        def setup
-          @factory = create_factory
-          @point1 = @factory.point(0, 0)
-          @point2 = @factory.point(1, 0)
-          @point3 = @factory.point(-4, 2)
-          @point4 = @factory.point(-5, 3)
-          @point5 = @factory.point(-5, 3)
-        end
-
-        def test_creation_simple
-          geom_ = @factory.multi_point([@point1, @point2])
-          assert_not_nil(geom_)
-          assert(::RGeo::Feature::MultiPoint === geom_)
-          assert_equal(::RGeo::Feature::MultiPoint, geom_.geometry_type)
-          assert_equal(2, geom_.num_geometries)
-          assert(@point1.eql?(geom_[0]))
-          assert(@point2.eql?(geom_[1]))
-        end
-
-        def test_creation_empty
-          geom_ = @factory.multi_point([])
-          assert_not_nil(geom_)
-          assert(::RGeo::Feature::MultiPoint === geom_)
-          assert_equal(::RGeo::Feature::MultiPoint, geom_.geometry_type)
-          assert_equal(0, geom_.num_geometries)
-          assert_equal([], geom_.to_a)
-        end
-
-        def test_creation_casting
-          mp1_ = @factory.collection([@point3])
-          mp2_ = @factory.multi_point([@point4])
-          geom_ = @factory.multi_point([@point1, @point2, mp1_, mp2_])
-          assert_not_nil(geom_)
-          assert_equal(::RGeo::Feature::MultiPoint, geom_.geometry_type)
-          assert_equal(4, geom_.num_geometries)
-          assert(@point1.eql?(geom_[0]))
-          assert(@point2.eql?(geom_[1]))
-          assert(@point3.eql?(geom_[2]))
-          assert(@point4.eql?(geom_[3]))
-        end
-
-        def test_creation_wrong_type
-          line_ = @factory.line_string([@point1, @point2])
-          geom_ = @factory.multi_point([@point3, line_])
-          assert_nil(geom_)
-        end
-
-        def test_required_equivalences
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = @factory.multi_point([@point1, @point2])
-          assert(geom1_.eql?(geom2_))
-          assert(geom1_ == geom2_)
-        end
-
-        def test_fully_equal
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = @factory.multi_point([@point1, @point2])
-          assert(geom1_.rep_equals?(geom2_))
-          assert(geom1_.equals?(geom2_))
-        end
-
-        def test_geometrically_equal
-          geom1_ = @factory.multi_point([@point1, @point4])
-          geom2_ = @factory.multi_point([@point1, @point4, @point5])
-          assert(!geom1_.rep_equals?(geom2_))
-          assert(geom1_.equals?(geom2_))
-        end
-
-        def test_not_equal
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = @factory.multi_point([@point1])
-          assert(!geom1_.rep_equals?(geom2_))
-          assert(!geom1_.equals?(geom2_))
-        end
-
-        def test_hashes_equal_for_representationally_equivalent_objects
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = @factory.multi_point([@point1, @point2])
-          assert_equal(geom1_.hash, geom2_.hash)
-        end
-
-        def test_wkt_creation_simple
-          parsed_geom_ = @factory.parse_wkt("MULTIPOINT((0 0), (-4 2), (-5 3))")
-          built_geom_ = @factory.multi_point([@point1, @point3, @point4])
-          assert(built_geom_.eql?(parsed_geom_))
-        end
-
-        def test_wkt_creation_empty
-          parsed_geom_ = @factory.parse_wkt("MULTIPOINT EMPTY")
-          assert(::RGeo::Feature::MultiPoint === parsed_geom_)
-          assert_equal(0, parsed_geom_.num_geometries)
-          assert_equal([], parsed_geom_.to_a)
-        end
-
-        def test_clone
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = geom1_.clone
-          assert(geom1_.eql?(geom2_))
-          assert_equal(::RGeo::Feature::MultiPoint, geom2_.geometry_type)
-          assert_equal(2, geom2_.num_geometries)
-          assert(@point1.eql?(geom2_[0]))
-          assert(@point2.eql?(geom2_[1]))
-        end
-
-        def test_type_check
-          geom1_ = @factory.multi_point([@point1, @point2])
-          assert(::RGeo::Feature::Geometry.check_type(geom1_))
-          assert(!::RGeo::Feature::Point.check_type(geom1_))
-          assert(::RGeo::Feature::GeometryCollection.check_type(geom1_))
-          assert(::RGeo::Feature::MultiPoint.check_type(geom1_))
-          assert(!::RGeo::Feature::MultiLineString.check_type(geom1_))
-          geom2_ = @factory.multi_point([])
-          assert(::RGeo::Feature::Geometry.check_type(geom2_))
-          assert(!::RGeo::Feature::Point.check_type(geom2_))
-          assert(::RGeo::Feature::GeometryCollection.check_type(geom2_))
-          assert(::RGeo::Feature::MultiPoint.check_type(geom2_))
-          assert(!::RGeo::Feature::MultiLineString.check_type(geom2_))
-        end
-
-        def test_as_text_wkt_round_trip
-          geom1_ = @factory.multi_point([@point1, @point2])
-          text_ = geom1_.as_text
-          geom2_ = @factory.parse_wkt(text_)
-          assert(geom1_.eql?(geom2_))
-        end
-
-        def test_as_binary_wkb_round_trip
-          geom1_ = @factory.multi_point([@point1, @point2])
-          binary_ = geom1_.as_binary
-          geom2_ = @factory.parse_wkb(binary_)
-          assert(geom1_.eql?(geom2_))
-        end
-
-        def test_dimension
-          geom1_ = @factory.multi_point([@point1, @point2])
-          assert_equal(0, geom1_.dimension)
-          geom2_ = @factory.multi_point([])
-          assert_equal(-1, geom2_.dimension)
-        end
-
-        def test_is_empty
-          geom1_ = @factory.multi_point([@point1, @point2])
-          assert(!geom1_.is_empty?)
-          geom2_ = @factory.multi_point([])
-          assert(geom2_.is_empty?)
-        end
-
-        def test_union
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = @factory.multi_point([@point1, @point3])
-          geom3_ = @factory.multi_point([@point1, @point2, @point3])
-          assert_equal(geom3_, geom1_.union(geom2_))
-          assert_equal(geom3_, geom1_ + geom2_)
-        end
-
-        def test_difference
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = @factory.multi_point([@point1, @point3])
-          assert_equal(@point2, geom1_.difference(geom2_))
-          assert_equal(@point2, geom1_ - geom2_)
-        end
-
-        def test_intersection
-          geom1_ = @factory.multi_point([@point1, @point2])
-          geom2_ = @factory.multi_point([@point1, @point3])
-          assert_equal(@point1, geom1_.intersection(geom2_))
-          assert_equal(@point1, geom1_ * geom2_)
-        end
-
-        def test_zm
-          factory_ = create_factory(has_z_coordinate: true, has_m_coordinate: true)
-          p1_ = factory_.point(1, 2, 3, 4)
-          mp_ = factory_.multi_point([p1_])
-          assert_equal(p1_, mp_[0])
-        end
-
-        def test_coordinate
-          p0 = @factory.point(0, 0)
-          p1 = @factory.point(1, 1)
-          p2 = @factory.point(2, 2)
-          points = [p0, p1, p2]
-          mp = @factory.multi_point(points)
-          assert_equal(mp.coordinates, points.map(&:coordinates))
-        end
-      end
-    end
-  end
-end

data/test/common/multi_polygon_tests.rb

@@ -1,191 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Common tests for multi polygon implementations
-#
-# -----------------------------------------------------------------------------
-
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module Common # :nodoc:
-      module MultiPolygonTests # :nodoc:
-        def setup
-          create_factories
-          point1_ = @factory.point(0, 0)
-          point2_ = @factory.point(0, 10)
-          point3_ = @factory.point(10, 10)
-          point4_ = @factory.point(10, 0)
-          point5_ = @factory.point(4, 4)
-          point6_ = @factory.point(5, 6)
-          point7_ = @factory.point(6, 4)
-          point8_ = @factory.point(0, -10)
-          point9_ = @factory.point(-10, 0)
-          exterior1_ = @factory.linear_ring([point1_, point8_, point9_, point1_])
-          exterior2_ = @factory.linear_ring([point1_, point2_, point3_, point4_, point1_])
-          exterior3_ = @factory.linear_ring([point1_, point2_, point3_, point1_])
-          exterior4_ = @factory.linear_ring([point1_, point3_, point4_, point1_])
-          interior1_ = @factory.linear_ring([point5_, point6_, point7_, point5_])
-          @poly1 = @factory.polygon(exterior1_)
-          @poly2 = @factory.polygon(exterior2_, [interior1_])
-          @poly3 = @factory.polygon(exterior3_)
-          @poly4 = @factory.polygon(exterior4_)
-          @line1 = interior1_
-        end
-
-        def test_creation_simple
-          geom_ = @factory.multi_polygon([@poly1, @poly2])
-          assert_not_nil(geom_)
-          assert(::RGeo::Feature::MultiPolygon === geom_)
-          assert_equal(::RGeo::Feature::MultiPolygon, geom_.geometry_type)
-          assert_equal(2, geom_.num_geometries)
-          assert(@poly1.eql?(geom_[0]))
-          assert(@poly2.eql?(geom_[1]))
-        end
-
-        def test_creation_empty
-          geom_ = @factory.multi_polygon([])
-          assert_not_nil(geom_)
-          assert(::RGeo::Feature::MultiPolygon === geom_)
-          assert_equal(::RGeo::Feature::MultiPolygon, geom_.geometry_type)
-          assert_equal(0, geom_.num_geometries)
-          assert_equal([], geom_.to_a)
-        end
-
-        def test_creation_wrong_type
-          geom_ = @factory.multi_polygon([@poly1, @line1])
-          assert_nil(geom_)
-        end
-
-        def test_creation_overlapping
-          geom_ = @factory.multi_polygon([@poly1, @poly1])
-          assert_nil(geom_)
-          geom2_ = @lenient_factory.multi_polygon([@poly1, @poly1])
-          assert_not_nil(geom2_)
-        end
-
-        def test_creation_connected
-          geom_ = @factory.multi_polygon([@poly3, @poly4])
-          assert_nil(geom_)
-          geom2_ = @lenient_factory.multi_polygon([@poly3, @poly4])
-          assert_not_nil(geom2_)
-        end
-
-        def test_required_equivalences
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          geom2_ = @factory.multi_polygon([@poly1, @poly2])
-          assert(geom1_.eql?(geom2_))
-          assert(geom1_ == geom2_)
-        end
-
-        def test_equal
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          geom2_ = @factory.multi_polygon([@poly1, @poly2])
-          assert(geom1_.rep_equals?(geom2_))
-          assert(geom1_.equals?(geom2_))
-        end
-
-        def test_not_equal
-          geom1_ = @factory.multi_polygon([@poly1])
-          geom2_ = @factory.multi_polygon([@poly2])
-          assert(!geom1_.rep_equals?(geom2_))
-          assert(!geom1_.equals?(geom2_))
-        end
-
-        def test_hashes_equal_for_representationally_equivalent_objects
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          geom2_ = @factory.multi_polygon([@poly1, @poly2])
-          assert_equal(geom1_.hash, geom2_.hash)
-        end
-
-        def test_wkt_creation_simple
-          parsed_geom_ = @factory.parse_wkt("MULTIPOLYGON(((0 0, 0 -10, -10 0, 0 0)), ((0 0, 0 10, 10 10, 10 0, 0 0), (4 4, 5 6, 6 4, 4 4)))")
-          built_geom_ = @factory.multi_polygon([@poly1, @poly2])
-          assert(built_geom_.eql?(parsed_geom_))
-        end
-
-        def test_wkt_creation_empty
-          parsed_geom_ = @factory.parse_wkt("MULTIPOLYGON EMPTY")
-          assert_equal(::RGeo::Feature::MultiPolygon, parsed_geom_.geometry_type)
-          assert_equal(0, parsed_geom_.num_geometries)
-          assert_equal([], parsed_geom_.to_a)
-        end
-
-        def test_clone
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          geom2_ = geom1_.clone
-          assert(geom1_.eql?(geom2_))
-          assert_equal(::RGeo::Feature::MultiPolygon, geom2_.geometry_type)
-          assert_equal(2, geom2_.num_geometries)
-          assert(@poly1.eql?(geom2_[0]))
-          assert(@poly2.eql?(geom2_[1]))
-        end
-
-        def test_type_check
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          assert(::RGeo::Feature::Geometry.check_type(geom1_))
-          assert(!::RGeo::Feature::Polygon.check_type(geom1_))
-          assert(::RGeo::Feature::GeometryCollection.check_type(geom1_))
-          assert(!::RGeo::Feature::MultiPoint.check_type(geom1_))
-          assert(::RGeo::Feature::MultiPolygon.check_type(geom1_))
-          geom2_ = @factory.multi_polygon([])
-          assert(::RGeo::Feature::Geometry.check_type(geom2_))
-          assert(!::RGeo::Feature::Polygon.check_type(geom2_))
-          assert(::RGeo::Feature::GeometryCollection.check_type(geom2_))
-          assert(!::RGeo::Feature::MultiPoint.check_type(geom2_))
-          assert(::RGeo::Feature::MultiPolygon.check_type(geom2_))
-        end
-
-        def test_as_text_wkt_round_trip
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          text_ = geom1_.as_text
-          geom2_ = @factory.parse_wkt(text_)
-          assert(geom1_.eql?(geom2_))
-        end
-
-        def test_as_binary_wkb_round_trip
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          binary_ = geom1_.as_binary
-          geom2_ = @factory.parse_wkb(binary_)
-          assert(geom1_.eql?(geom2_))
-        end
-
-        def test_dimension
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          assert_equal(2, geom1_.dimension)
-          geom2_ = @factory.multi_polygon([])
-          assert_equal(-1, geom2_.dimension)
-        end
-
-        def test_is_empty
-          geom1_ = @factory.multi_polygon([@poly1, @poly2])
-          assert(!geom1_.is_empty?)
-          geom2_ = @factory.multi_polygon([])
-          assert(geom2_.is_empty?)
-        end
-
-        def test_multi_polygon_coordinates
-          poly1_coordinates = [
-            [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0]],
-            [[0.25, 0.25], [0.75, 0.25], [0.75, 0.75], [0.25, 0.75], [0.25, 0.25]]
-          ]
-          poly2_coordinates = [
-            [[2.0, 2.0], [3.0, 2.0], [3.0, 3.0], [2.0, 3.0], [2.0, 2.0]],
-            [[2.25, 2.25], [2.75, 2.25], [2.75, 2.75], [2.25, 2.75], [2.25, 2.25]]
-          ]
-
-          ring = @factory.line_string(poly1_coordinates.first.map { |(x, y)| @factory.point x, y })
-          inner_ring = @factory.line_string(poly1_coordinates.last.map { |(x, y)| @factory.point x, y })
-          poly1 = @factory.polygon ring, [inner_ring]
-
-          ring = @factory.line_string(poly2_coordinates.first.map { |(x, y)| @factory.point x, y })
-          inner_ring = @factory.line_string(poly2_coordinates.last.map { |(x, y)| @factory.point x, y })
-          poly2 = @factory.polygon ring, [inner_ring]
-
-          multi_polygon = @factory.multi_polygon [poly1, poly2]
-          assert_equal(multi_polygon.coordinates, [poly1_coordinates, poly2_coordinates])
-        end
-      end
-    end
-  end
-end

data/test/common/point_tests.rb

@@ -1,370 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Common tests for point implementations
-#
-# -----------------------------------------------------------------------------
-
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module Common # :nodoc:
-      module PointTests # :nodoc:
-        def assert_close_enough(p1_, p2_)
-          assert((p1_.x - p2_.x).abs < 0.00000001 && (p1_.y - p2_.y).abs < 0.00000001)
-        end
-
-        def assert_contains_approx(p_, mp_)
-          assert(mp_.any? { |q_| (p_.x - q_.x).abs < 0.00000001 && (p_.y - q_.y).abs < 0.00000001 })
-        end
-
-        def test_creation
-          point_ = @factory.point(21, -22)
-          assert_equal(21, point_.x)
-          assert_equal(-22, point_.y)
-        end
-
-        def test_wkt_creation
-          point1_ = @factory.parse_wkt("Point (21 -22)")
-          assert_equal(21, point1_.x)
-          assert_equal(-22, point1_.y)
-        end
-
-        def test_clone
-          point1_ = @factory.point(11, 12)
-          point2_ = point1_.clone
-          assert_equal(point1_, point2_)
-          point3_ = @factory.point(13, 12)
-          point4_ = point3_.dup
-          assert_equal(point3_, point4_)
-          assert_not_equal(point2_, point4_)
-        end
-
-        def test_type_check
-          point_ = @factory.point(21, 22)
-          assert(::RGeo::Feature::Geometry.check_type(point_))
-          assert(::RGeo::Feature::Point.check_type(point_))
-          assert(!::RGeo::Feature::GeometryCollection.check_type(point_))
-          assert(!::RGeo::Feature::Curve.check_type(point_))
-        end
-
-        def test_geometry_type
-          point_ = @factory.point(11, 12)
-          assert_equal(::RGeo::Feature::Point, point_.geometry_type)
-        end
-
-        def test_dimension
-          point_ = @factory.point(11, 12)
-          assert_equal(0, point_.dimension)
-        end
-
-        def test_envelope
-          point_ = @factory.point(11, 12)
-          assert_close_enough(point_, point_.envelope)
-        end
-
-        def test_as_text
-          point_ = @factory.point(11, 12)
-          assert_equal("POINT (11.0 12.0)", point_.as_text)
-        end
-
-        def test_as_text_wkt_round_trip
-          point1_ = @factory.point(11, 12)
-          text_ = point1_.as_text
-          point2_ = @factory.parse_wkt(text_)
-          assert_equal(point2_, point1_)
-        end
-
-        def test_as_binary_wkb_round_trip
-          point1_ = @factory.point(211, 12)
-          binary_ = point1_.as_binary
-          point2_ = @factory.parse_wkb(binary_)
-          assert_equal(point2_, point1_)
-        end
-
-        def test_is_empty
-          point1_ = @factory.point(0, 0)
-          assert(!point1_.is_empty?)
-        end
-
-        def test_is_simple
-          point1_ = @factory.point(0, 0)
-          assert(point1_.is_simple?)
-        end
-
-        def test_boundary
-          point_ = @factory.point(11, 12)
-          boundary_ = point_.boundary
-          assert(boundary_.is_empty?)
-        end
-
-        def test_equals
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(13, 12)
-          assert(point1_.equals?(point2_))
-          assert(point1_ == point2_)
-          assert(point1_.rep_equals?(point2_))
-          assert(point1_.eql?(point2_))
-          assert(!point1_.equals?(point3_))
-          assert(point1_ != point3_)
-          assert(!point1_.rep_equals?(point3_))
-          assert(!point1_.eql?(point3_))
-          assert(point1_ != "hello")
-          assert(!point1_.eql?("hello"))
-        end
-
-        def test_out_of_order_is_not_equal
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(12, 11)
-          assert_not_equal(point1_, point2_)
-          assert_not_equal(point1_.hash, point2_.hash)
-        end
-
-        def test_hashes_equal_for_representationally_equivalent_objects
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          assert_equal(point1_.hash, point2_.hash)
-        end
-
-        def test_point_as_hash_key
-          hash_ = { @factory.point(11, 12) => :hello }
-          assert_equal(:hello, hash_[@factory.point(11, 12)])
-        end
-
-        def test_disjoint
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert(!point1_.disjoint?(point2_))
-          assert(point1_.disjoint?(point3_))
-        end
-
-        def test_intersects
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert(point1_.intersects?(point2_))
-          assert(!point1_.intersects?(point3_))
-        end
-
-        def test_touches
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert(!point1_.touches?(point2_))
-          assert(!point1_.touches?(point3_))
-        end
-
-        def test_crosses
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert(!point1_.crosses?(point2_))
-          assert(!point1_.crosses?(point3_))
-        end
-
-        def test_within
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert(point1_.within?(point2_))
-          assert(!point1_.within?(point3_))
-        end
-
-        def test_contains
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert(point1_.contains?(point2_))
-          assert(!point1_.contains?(point3_))
-        end
-
-        def test_overlaps
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert(!point1_.overlaps?(point2_))
-          assert(!point1_.overlaps?(point3_))
-        end
-
-        def test_convex_hull
-          point_ = @factory.point(11, 12)
-          assert_close_enough(point_, point_.convex_hull)
-        end
-
-        def test_intersection
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          assert_close_enough(point1_, point1_.intersection(point2_))
-          int13_ = point1_.intersection(point3_)
-          assert(int13_.is_empty?)
-        end
-
-        def test_union
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          union12_ = point1_.union(point2_)
-          union13_ = point1_.union(point3_)
-          assert_close_enough(point1_, union12_)
-          assert_equal(::RGeo::Feature::MultiPoint, union13_.geometry_type)
-          assert_contains_approx(point1_, union13_)
-          assert_contains_approx(point3_, union13_)
-        end
-
-        def test_difference
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          diff12_ = point1_.difference(point2_)
-          diff13_ = point1_.difference(point3_)
-          assert_equal(::RGeo::Feature::GeometryCollection, diff12_.geometry_type)
-          assert(diff12_.is_empty?)
-          assert_close_enough(point1_, diff13_)
-        end
-
-        def test_sym_difference
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(12, 12)
-          diff12_ = point1_.sym_difference(point2_)
-          diff13_ = point1_.sym_difference(point3_)
-          assert_equal(::RGeo::Feature::GeometryCollection, diff12_.geometry_type)
-          assert(diff12_.is_empty?)
-          assert_equal(::RGeo::Feature::MultiPoint, diff13_.geometry_type)
-          assert_contains_approx(point1_, diff13_)
-          assert_contains_approx(point3_, diff13_)
-        end
-
-        def test_buffer
-          point_ = @factory.point(11, 12)
-          buffer_ = point_.buffer(4)
-          assert_equal(::RGeo::Feature::Polygon, buffer_.geometry_type)
-          assert_equal(33, buffer_.exterior_ring.num_points)
-        end
-
-        def test_3dz_creation
-          point_ = @zfactory.point(11, 12, 13)
-          assert_equal(11, point_.x)
-          assert_equal(12, point_.y)
-          assert_equal(13, point_.z)
-          point2_ = @zfactory.point(21, 22)
-          assert_equal(21, point2_.x)
-          assert_equal(22, point2_.y)
-          assert_equal(0, point2_.z)
-        end
-
-        def test_3dm_creation
-          point_ = @mfactory.point(11, 12, 13)
-          assert_equal(11, point_.x)
-          assert_equal(12, point_.y)
-          assert_equal(13, point_.m)
-          point2_ = @mfactory.point(21, 22)
-          assert_equal(21, point2_.x)
-          assert_equal(22, point2_.y)
-          assert_equal(0, point2_.m)
-        end
-
-        def test_4d_creation
-          point_ = @zmfactory.point(11, 12, 13, 14)
-          assert_equal(11, point_.x)
-          assert_equal(12, point_.y)
-          assert_equal(13, point_.z)
-          assert_equal(14, point_.m)
-          point2_ = @zmfactory.point(21, 22)
-          assert_equal(21, point2_.x)
-          assert_equal(22, point2_.y)
-          assert_equal(0, point2_.z)
-          assert_equal(0, point2_.m)
-        end
-
-        def test_wkt_creation_3d
-          point2_ = @zfactory.parse_wkt("POINT(11 12 13)")
-          assert_equal(11, point2_.x)
-          assert_equal(12, point2_.y)
-          assert_equal(13, point2_.z)
-          point1_ = @zfactory.parse_wkt("POINT(21 22)")
-          assert_equal(21, point1_.x)
-          assert_equal(22, point1_.y)
-          # Z is undefined in this case.
-          # We'd like to define it to be 0, but the GEOS
-          # parser doesn't behave that way.
-        end
-
-        def test_marshal_roundtrip
-          point_ = @factory.point(11, 12)
-          data_ = ::Marshal.dump(point_)
-          point2_ = ::Marshal.load(data_)
-          assert_equal(point_, point2_)
-        end
-
-        def test_marshal_roundtrip_3d
-          point_ = @zfactory.point(11, 12, 13)
-          data_ = ::Marshal.dump(point_)
-          point2_ = ::Marshal.load(data_)
-          assert_equal(point_, point2_)
-        end
-
-        def test_marshal_roundtrip_4d
-          point_ = @zmfactory.point(11, 12, 13, 14)
-          data_ = ::Marshal.dump(point_)
-          point2_ = ::Marshal.load(data_)
-          assert_equal(point_, point2_)
-        end
-
-        def test_coordinates
-          point_ = @factory.point(11.0, 12.0)
-          assert_equal([11.0, 12.0], point_.coordinates)
-        end
-
-        def test_coordinates_3dz
-          point_ = @zfactory.point(11, 12, 13)
-          assert_equal([11.0, 12.0, 13.0], point_.coordinates)
-          point2_ = @zfactory.point(21, 22)
-          assert_equal([21.0, 22.0, 0.0], point2_.coordinates)
-        end
-
-        def test_coordinates_3dm
-          point_ = @mfactory.point(11, 12, 13)
-          assert_equal([11.0, 12.0, 13.0], point_.coordinates)
-          point2_ = @mfactory.point(21, 22)
-          assert_equal([21.0, 22.0, 0.0], point2_.coordinates)
-        end
-
-        def test_coordinates_4d
-          point_ = @zmfactory.point(11, 12, 13, 14)
-          assert_equal([11.0, 12.0, 13.0, 14.0], point_.coordinates)
-          point2_ = @zmfactory.point(21, 22)
-          assert_equal([21.0, 22.0, 0.0, 0.0], point2_.coordinates)
-        end
-
-        if ::RGeo.yaml_supported?
-
-          def test_psych_roundtrip
-            point_ = @factory.point(11, 12)
-            data_ = ::Psych.dump(point_)
-            point2_ = ::Psych.load(data_)
-            assert_equal(point_, point2_)
-          end
-
-          def test_psych_roundtrip_3d
-            point_ = @zfactory.point(11, 12, 13)
-            data_ = ::Psych.dump(point_)
-            point2_ = ::Psych.load(data_)
-            assert_equal(point_, point2_)
-          end
-
-          def test_psych_roundtrip_4d
-            point_ = @zmfactory.point(11, 12, 13, 14)
-            data_ = ::Psych.dump(point_)
-            point2_ = ::Psych.load(data_)
-            assert_equal(point_, point2_)
-          end
-
-        end
-      end
-    end
-  end
-end