geometry-in-ruby 0.0.1

data/test/geometry/polygon.rb

@@ -0,0 +1,214 @@
+require 'minitest/autorun'
+require 'geometry/polygon'
+
+describe Geometry::Polygon do
+    Polygon = Geometry::Polygon
+
+    let(:cw_unit_square) { Polygon.new [0,0], [0,1], [1,1], [1,0] }
+    let(:unit_square) { Polygon.new [0,0], [1,0], [1,1], [0,1] }
+    let(:simple_concave) { Polygon.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2] }
+    subject { unit_square }
+
+    it "must create a Polygon object with no arguments" do
+	polygon = Geometry::Polygon.new
+	assert_kind_of(Geometry::Polygon, polygon)
+	assert_equal(0, polygon.edges.size)
+	assert_equal(0, polygon.vertices.size)
+    end
+
+    it "must create a Polygon object from array arguments" do
+	polygon = Geometry::Polygon.new([0,0], [1,0], [1,1], [0,1])
+	assert_kind_of(Geometry::Polygon, polygon)
+	assert_equal(4, polygon.edges.size)
+	assert_equal(4, polygon.vertices.size)
+    end
+
+    describe "when creating a Polygon from an array of Points" do
+	it "must ignore repeated Points" do
+	    polygon = Geometry::Polygon.new([0,0], [1,0], [1,1], [1,1], [0,1])
+	    polygon.must_be_kind_of Geometry::Polygon
+	    polygon.edges.size.must_equal 4
+	    polygon.vertices.size.must_equal 4
+	    polygon.must_equal Geometry::Polygon.new([0,0], [1,0], [1,1], [0,1])
+	end
+
+	it "must collapse collinear Edges" do
+	    polygon = Geometry::Polygon.new([0,0], [1,0], [1,1], [0.5,1], [0,1])
+	    polygon.must_equal Geometry::Polygon.new([0,0], [1,0], [1,1], [0,1])
+	end
+
+	it "must collapse backtracking Edges" do
+	    polygon = Geometry::Polygon.new [0,0], [2,0], [2,2], [1,2], [1,1], [1,2], [0,2]
+	    polygon.must_equal Geometry::Polygon.new([0,0], [2,0], [2,2], [0,2])
+	end
+    end
+
+    it "must compare identical polygons as equal" do
+	(unit_square.eql? unit_square).must_equal true
+    end
+
+    it "must create closed polygons" do
+	subject.closed?.must_equal true
+    end
+
+    it "must handle already closed polygons" do
+	polygon = Geometry::Polygon.new([0,0], [1,0], [1,1], [0,1], [0,0])
+	assert_kind_of(Geometry::Polygon, polygon)
+	assert_equal(4, polygon.edges.size)
+	assert_equal(4, polygon.vertices.size)
+	assert_equal(polygon.edges.first.first, polygon.edges.last.last)
+    end
+
+    it "must return itself on close" do
+	closed = subject.close
+	closed.closed?.must_equal true
+	closed.must_equal subject
+	closed.must_be_same_as subject
+    end
+
+    describe "orientation" do
+	it "must return true for clockwise" do
+	    Polygon.new([0,0], [0,1], [1,1], [1,0]).clockwise?.must_equal true
+	    Polygon.new([1,1], [1,3], [3,3], [3,1]).clockwise?.must_equal true
+	end
+
+	it "must return false for counterclockwise" do
+	    Polygon.new([0,0], [1,0], [1,1], [0,1]).clockwise?.must_equal false
+	    Polygon.new([1,1], [3,1], [3,3], [1,3]).clockwise?.must_equal false
+	end
+    end
+
+    it "must gift wrap a square polygon" do
+	polygon = Polygon.new [0,0], [1,0], [1,1], [0,1]
+	convex_hull = polygon.wrap
+	convex_hull.must_be_kind_of Geometry::Polygon
+	convex_hull.edges.size.must_equal 4
+	convex_hull.vertices.must_equal [[0,0], [0,1], [1,1], [1,0]].map {|a| Point[*a]}
+    end
+
+    it "must gift wrap another square polygon" do
+	polygon = Polygon.new [0,1], [0,0], [1,0], [1,1]
+	convex_hull = polygon.wrap
+	convex_hull.must_be_kind_of Geometry::Polygon
+	convex_hull.edges.size.must_equal 4
+	convex_hull.vertices.must_equal [[0,0], [0,1], [1,1], [1,0]].map {|a| Point[*a]}
+    end
+
+    it "must gift wrap a concave polygon" do
+	polygon = Polygon.new [0,0], [1,-1], [2,0], [1,1], [2,2], [0,1]
+	convex_hull = polygon.wrap
+	convex_hull.must_be_kind_of Geometry::Polygon
+	convex_hull.edges.size.must_equal 5
+	convex_hull.vertices.must_equal [Point[0, 0], Point[0, 1], Point[2, 2], Point[2, 0], Point[1, -1]]
+    end
+
+    it "must gift wrap a polygon" do
+	polygon = Polygon.new [0,0], [1,-1], [2,0], [2,1], [0,1]
+	convex_hull = polygon.wrap
+	convex_hull.must_be_kind_of Geometry::Polygon
+	convex_hull.edges.size.must_equal 5
+	convex_hull.vertices.must_equal [[0,0], [0,1], [2,1], [2,0], [1,-1]].map {|a| Point[*a]}
+    end
+
+    it "must generate spokes" do
+	unit_square.spokes.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	cw_unit_square.spokes.must_equal [Vector[-1,-1], Vector[-1,1], Vector[1,1], Vector[1,-1]]
+	simple_concave.spokes.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1], Vector[-1,1], Vector[1,1], Vector[1,1], Vector[-1,1]]
+    end
+
+    describe "spaceship" do
+	it "with a Point" do
+	    (unit_square <=> Point[2,0]).must_equal -1
+	    (unit_square <=> Point[1,0]).must_equal 0
+	    (unit_square <=> Point[0.5,0.5]).must_equal 1
+	end
+
+	it "with a Point that lies on a horizontal edge" do
+	    (unit_square <=> Point[0.5,0]).must_equal 0
+	end
+    end
+
+    describe "when outsetting" do
+	it "must outset a unit square" do
+	    outset_polygon = unit_square.outset(1)
+	    expected_polygon = Polygon.new [-1.0,-1.0], [2.0,-1.0], [2.0,2.0], [-1.0,2.0]
+	    outset_polygon.must_equal expected_polygon
+	end
+
+	it "must outset a simple concave polygon" do
+	    concave_polygon = Polygon.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2]
+	    outset_polygon = concave_polygon.outset(1)
+	    outset_polygon.must_equal Polygon.new [-1,-1], [5,-1], [5,3], [-1,3]
+	end
+
+	it "must outset a concave polygon" do
+	    concave_polygon = Polygon.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2]
+	    outset_polygon = concave_polygon.outset(2)
+	    outset_polygon.must_equal Polygon.new [-2,-2], [6,-2], [6,4], [-2,4]
+	end
+
+	it "must outset an asymetric concave polygon" do
+	    concave_polygon = Polygon.new [0,0], [4,0], [4,3], [3,3], [3,1], [1,1], [1,2], [0,2]
+	    outset_polygon = concave_polygon.outset(2)
+	    outset_polygon.must_equal Polygon.new [-2,-2], [6,-2], [6,5], [1,5], [1,4], [-2,4]
+	end
+
+	it "must outset a concave polygon with multiply-intersecting edges" do
+	    concave_polygon = Polygon.new [0,0], [5,0], [5,2], [4,2], [4,1], [3,1], [3,2], [2,2], [2,1], [1,1], [1,2], [0,2]
+	    outset_polygon = concave_polygon.outset(1)
+	    outset_polygon.must_equal Polygon.new [-1,-1], [6,-1], [6,3], [-1,3]
+	end
+
+	it "must outset a concave polygon where the first outset edge intersects with the last outset edge" do
+	    polygon = Polygon.new [0,0], [0,1], [2,1], [2,2], [-1,2], [-1,-1], [2,-1], [2,0]
+	    polygon.edges.count.must_equal 8
+	    polygon.outset(1).must_equal Polygon.new [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
+	end
+
+	# Naturally, this test is very sensitive to the input coordinate values. This is a painfully contrived example that
+	#  checks for sensitivity to edges that are very close to horizontal, but not quite.
+	# When the test fails, the first point of the offset polygon is at [0,-1]
+	it "must not be sensitive to floating point rounding errors" do
+	    polygon = Polygon.new [0, 0], [0, -2], [10, -2], [10, 10], [-100, 10], [-100, -22], [-69, -22], [-69, 3.552713678800501e-15], [0,0]
+	    outset = polygon.outset(1)
+	    outset.edges.first.first.must_equal Geometry::Point[-1,-1]
+	end
+    end
+
+    describe "set operations" do
+	describe "union" do
+	    it "must union two adjacent squares" do
+		polygonA = Polygon.new [0,0], [1,0], [1,1], [0,1]
+		polygonB = Polygon.new [1,0], [2,0], [2,1], [1,1]
+		(polygonA.union polygonB).must_equal Polygon.new [0,0], [2,0], [2,1], [0,1]
+		(polygonA + polygonB).must_equal Polygon.new [0,0], [2,0], [2,1], [0,1]
+	    end
+
+	    it "must union two overlapping squares" do
+		polygonA = Polygon.new [0,0], [2,0], [2,2], [0,2]
+		polygonB = Polygon.new [1,1], [3,1], [3,3], [1,3]
+		expected_polygon = Polygon.new [0,0], [2,0], [2,1], [3,1], [3,3], [1,3], [1,2], [0,2]
+		union = polygonA.union polygonB
+		union.must_be_kind_of Polygon
+		union.must_equal expected_polygon
+	    end
+
+	    it "must union two overlapping clockwise squares" do
+		polygonA = Polygon.new [0,0], [0,2], [2,2], [2,0]
+		polygonB = Polygon.new [1,1], [1,3], [3,3], [3,1]
+		expected_polygon = Polygon.new [0, 0], [0, 2], [1, 2], [1, 3], [3, 3], [3, 1], [2, 1], [2, 0]
+		union = polygonA.union polygonB
+		union.must_be_kind_of Polygon
+		union.must_equal expected_polygon
+	    end
+
+	    it "must union two overlapping squares with collinear edges" do
+		polygonA = Polygon.new [0,0], [2,0], [2,2], [0,2]
+		polygonB = Polygon.new [1,0], [3,0], [3,2], [1,2]
+		union = polygonA + polygonB
+		union.must_be_kind_of Polygon
+		union.must_equal Polygon.new [0,0], [3,0], [3,2], [0,2]
+	    end
+	end
+    end
+end

data/test/geometry/polyline.rb

@@ -0,0 +1,266 @@
+require 'minitest/autorun'
+require 'geometry/polyline'
+
+describe Geometry::Polyline do
+    Polyline = Geometry::Polyline
+
+    let(:closed_unit_square) { Polyline.new [0,0], [1,0], [1,1], [0,1], [0,0] }
+    let(:unit_square) { Polyline.new [0,0], [1,0], [1,1], [0,1] }
+    let(:reverse_unit_square)	{ Polyline.new [0,1], [1,1], [1,0], [0,0] }
+
+    it "must create a Polyline object with no arguments" do
+	polyline = Geometry::Polyline.new
+	polyline.must_be_kind_of Polyline
+	polyline.edges.count.must_equal 0
+	polyline.vertices.count.must_equal 0
+    end
+
+    it "must create a Polyline object from array arguments" do
+	polyline = Geometry::Polyline.new([0,0], [1,0], [1,1], [0,1])
+	polyline.must_be_kind_of Polyline
+	polyline.edges.count.must_equal 3
+	polyline.vertices.count.must_equal 4
+    end
+
+    describe "when the Polyline is closed" do
+	let(:closed_concave_polyline) { Polyline.new [-2,0], [0,0], [0,-2], [2,-2], [2,2], [-2,2], [-2,0] }
+	subject { closed_concave_polyline }
+
+	it "must be closed" do
+	    closed_unit_square.closed?.must_equal true
+	end
+
+	it "must clone and close" do
+	    closed = subject.close
+	    closed.closed?.must_equal true
+	    closed.must_equal subject
+	    closed.wont_be_same_as subject
+	end
+
+	it "must be able to close itself" do
+	    subject.close!
+	    subject.closed?.must_equal true
+	    subject.must_equal subject
+	end
+
+	it "must clone and reverse" do
+	    vertices = subject.vertices
+	    vertices.push vertices.shift
+	    reversed = subject.reverse
+	    reversed.vertices.must_equal vertices.reverse
+	    reversed.wont_be_same_as subject
+	    reversed.closed?.must_equal true
+	end
+
+	it "must reverse itself" do
+	    original = subject.vertices.dup
+	    subject.reverse!
+	    subject.vertices.to_a.must_equal original.reverse
+	    subject.closed?.must_equal true
+	end
+
+	it "must generate bisectors" do
+	    closed_unit_square.bisectors.must_equal [Vector[1, 1], Vector[-1, 1], Vector[-1, -1], Vector[1, -1]]
+	end
+
+	it "must generate bisectors with an inside corner" do
+	    closed_concave_polyline.bisectors.must_equal [Vector[1,1], Vector[-1,-1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[1,-1]]
+	end
+
+	it "must generate left bisectors" do
+	    closed_unit_square.left_bisectors.must_equal [Vector[1, 1], Vector[-1, 1], Vector[-1, -1], Vector[1, -1]]
+	end
+
+	it "must generate left bisectors with an inside corner" do
+	    closed_concave_polyline.left_bisectors.must_equal [Vector[1,1], Vector[1,1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[1,-1]]
+	end
+
+	it "must generate right bisectors" do
+	    closed_unit_square.right_bisectors.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	end
+
+	it "must generate right bisectors with an inside corner" do
+	    closed_concave_polyline.right_bisectors.must_equal [Vector[-1,-1], Vector[-1,-1], Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	end
+
+	it "must generate spokes" do
+	    closed_unit_square.spokes.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	end
+
+	it "must rightset a closed concave polyline where the first outset edge intersects with the last outset edge" do
+	    skip
+	    polyline = Polyline.new [0,0], [0,1], [2,1], [2,2], [-1,2], [-1,-1], [2,-1], [2,0], [0,0]
+	    polyline.offset(-1).must_equal Polyline.new [1, 0], [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
+	end
+    end
+
+    describe "when the Polyline is open" do
+	let(:concave_polyline) { Polyline.new [-2,0], [0,0], [0,-2], [2,-2], [2,2], [-2,2] }
+	subject { concave_polyline }
+
+	it "must not be closed" do
+	    unit_square.closed?.must_equal false
+	end
+
+	it "must clone and close" do
+	    closed = subject.close
+	    closed.closed?.must_equal true
+	    closed.must_equal subject
+	    closed.wont_be_same_as subject
+	end
+
+	it "must be able to close it" do
+	    closed = subject.close!
+	    closed.closed?.must_equal true
+	    closed.must_equal subject
+	    closed.must_be_same_as subject
+	end
+
+	it "must clone and reverse" do
+	    reversed = subject.reverse
+	    reversed.vertices.must_equal subject.vertices.reverse
+	    reversed.wont_be_same_as subject
+	    reversed.closed?.wont_equal true
+	end
+
+	it "must reverse itself" do
+	    original = subject.vertices.dup
+	    subject.reverse!
+	    subject.vertices.to_a.must_equal original.reverse
+	    subject.closed?.wont_equal true
+	end
+
+	it "must generate bisectors" do
+	    unit_square.bisectors.must_equal [Vector[0, 1], Vector[-1, 1], Vector[-1, -1], Vector[0, -1]]
+	end
+
+	it "must generate bisectors with an inside corner" do
+	    concave_polyline.bisectors.must_equal [Vector[0,1], Vector[-1,-1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[0,-1]]
+	end
+
+	it "must generate left bisectors" do
+	    unit_square.left_bisectors.must_equal [Vector[0, 1], Vector[-1, 1], Vector[-1, -1], Vector[0, -1]]
+	    reverse_unit_square.left_bisectors.must_equal [Vector[0, 1], Vector[1, 1], Vector[1, -1], Vector[0, -1]]
+	end
+
+	it "must generate right bisectors" do
+	    unit_square.right_bisectors.must_equal [Vector[0,-1], Vector[1,-1], Vector[1,1], Vector[0,1]]
+	end
+
+	it "must generate right bisectors with an inside corner" do
+	    concave_polyline.right_bisectors.must_equal [Vector[0,-1], Vector[-1,-1], Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[0,1]]
+	end
+
+	it "must generate left bisectors with an inside corner" do
+	    concave_polyline.left_bisectors.must_equal [Vector[0,1], Vector[1,1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[0,-1]]
+	end
+
+	it "must generate spokes" do
+	    unit_square.spokes.must_equal [Vector[0,-1], Vector[1,-1], Vector[1,1], Vector[0,1]]
+	end
+    end
+
+    describe "when checking for closedness" do
+	it "must be closed when it is closed" do
+	    closed_unit_square.closed?.must_equal true
+	end
+
+	it "must not be closed when it is not closed" do
+	    unit_square.closed?.must_equal false
+	end
+    end
+
+    describe "when creating a Polyline from an array of Points" do
+	it "must ignore repeated Points" do
+	    polyline = Geometry::Polyline.new([0,0], [1,0], [1,1], [1,1], [0,1])
+	    polyline.must_be_kind_of Geometry::Polyline
+	    polyline.must_equal Geometry::Polyline.new([0,0], [1,0], [1,1], [0,1])
+	end
+
+	it "must collapse collinear Edges" do
+	    polyline = Geometry::Polyline.new([0,0], [1,0], [1,1], [0.5,1], [0,1])
+	    polyline.must_equal Geometry::Polyline.new([0,0], [1,0], [1,1], [0,1])
+	end
+
+	it "must collapse backtracking Edges" do
+	    polyline = Geometry::Polyline.new [0,0], [2,0], [2,2], [1,2], [1,1], [1,2], [0,2]
+	    polyline.must_equal Geometry::Polyline.new([0,0], [2,0], [2,2], [0,2])
+	end
+    end
+
+    it "must compare identical polylines as equal" do
+	(unit_square.eql? unit_square).must_equal true
+    end
+
+    it "must rightset a closed concave polyline where the first outset edge intersects with the last outset edge" do
+	skip
+	polyline = Polyline.new [0,0], [0,1], [2,1], [2,2], [-1,2], [-1,-1], [2,-1], [2,0], [0,0]
+	polyline.offset(-1).must_equal Polyline.new [1, 0], [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
+    end
+
+    describe "when offsetting" do
+	describe "with a positive offset" do
+	    it "must leftset a unit square" do
+		expected_polyline = Polyline.new [0,0.1], [0.9,0.1], [0.9,0.9], [0,0.9]
+		unit_square.offset(0.1).must_equal expected_polyline
+	    end
+
+	    it "must leftset a simple concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,4], [3,4], [3,3], [1,3], [1,4], [0,4]
+		offset_polyline = concave_polyline.offset(1)
+		offset_polyline.must_equal Polyline.new [0,1], [3,1], [3,2], [0,2], [0,3]
+	    end
+	end
+
+	describe "with a negative offset" do
+	    it "must rightset a unit square" do
+		expected_polyline = Polyline.new [0,-1.0], [2.0,-1.0], [2.0,2.0], [0,2.0]
+		unit_square.offset(-1).must_equal expected_polyline
+	    end
+
+	    it "must rightset a simple concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2]
+		offset_polyline = concave_polyline.offset(-1)
+		offset_polyline.must_equal Polyline.new [0,-1], [5,-1], [5,3], [0,3]
+	    end
+
+	    it "must rightset a concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2]
+		offset_polyline = concave_polyline.offset(-2)
+		offset_polyline.must_equal Polyline.new [0,-2], [6,-2], [6,4], [0,4]
+	    end
+
+	    it "must rightset an asymetric concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,3], [3,3], [3,1], [1,1], [1,2], [0,2]
+		offset_polyline = concave_polyline.offset(-2)
+		offset_polyline.must_equal Polyline.new [0,-2], [6,-2], [6,5], [1,5], [1,4], [0,4]
+	    end
+
+	    it "must rightset a concave polyline with multiply-intersecting edges" do
+		concave_polyline = Polyline.new [0,0], [5,0], [5,2], [4,2], [4,1], [3,1], [3,2], [2,2], [2,1], [1,1], [1,2], [0,2]
+		offset_polyline = concave_polyline.offset(-2)
+		offset_polyline.must_equal Polyline.new [0,-2], [7,-2], [7,4], [0,4]
+	    end
+
+	    it "must rightset a closed concave polyline with multiply-intersecting edges" do
+		concave_polyline = Polyline.new [0,0], [5,0], [5,2], [4,2], [4,1], [3,1], [3,2], [2,2], [2,1], [1,1], [1,2], [0,2], [0,0]
+		offset_polyline = concave_polyline.offset(-2)
+		offset_polyline.must_equal Polyline.new [-2,-2], [7,-2], [7,4], [-2,4]
+	    end
+
+	    it "must rightset a concave polyline where the first outset edge intersects with the last outset edge" do
+		polyline = Polyline.new [0,0], [0,1], [2,1], [2,2], [-1,2], [-1,-1], [2,-1], [2,0]
+		polyline.offset(-1).must_equal Polyline.new [1, 0], [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
+	    end
+
+	    # Naturally, this test is very sensitive to the input coordinate values. This is a painfully contrived example that
+	    #  checks for sensitivity to edges that are very close to horizontal, but not quite.
+	    # When the test fails, the first point of the offset polyline is at [0,-1]
+	    it "must not be sensitive to floating point rounding errors" do
+		polyline = Polyline.new [0, 0], [0, -2], [10, -2], [10, 10], [-100, 10], [-100, -22], [-69, -22], [-69, 3.552713678800501e-15], [0,0]
+		outset = polyline.offset(-1)
+		outset.edges.first.first.must_equal Geometry::Point[-1,-1]
+	    end
+	end
+    end
+end

data/test/geometry/rectangle.rb

@@ -0,0 +1,154 @@
+require 'minitest/autorun'
+require 'geometry/rectangle'
+
+def Rectangle(*args)
+    Geometry::Rectangle.new(*args)
+end
+
+describe Geometry::Rectangle do
+    Rectangle = Geometry::Rectangle
+
+    describe "when initializing" do
+	it "must accept two corners as Arrays" do
+	    rectangle = Rectangle.new [1,2], [2,3]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 1
+	    rectangle.width.must_equal 1
+	    rectangle.origin.must_equal Point[1,2]
+	end
+
+	it "must accept two named corners as Arrays" do
+	    rectangle = Rectangle.new from:[1,2], to:[2,3]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 1
+	    rectangle.width.must_equal 1
+	    rectangle.origin.must_equal Point[1,2]
+	end
+
+	it "must accept named center point and size arguments" do
+	    rectangle = Rectangle.new center:[1,2], size:[3,4]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 4
+	    rectangle.width.must_equal 3
+	    rectangle.center.must_equal Point[1,2]
+	end
+
+	it "must reject a named center argument with no size argument" do
+	    -> { Rectangle.new center:[1,2] }.must_raise ArgumentError
+	end
+
+	it "must accept named origin point and size arguments" do
+	    rectangle = Rectangle.new origin:[1,2], size:[3,4]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 4
+	    rectangle.width.must_equal 3
+	    rectangle.origin.must_equal Point[1,2]
+	end
+
+	it "must reject a named origin argument with no size argument" do
+	    -> { Rectangle.new origin:[1,2] }.must_raise ArgumentError
+	end
+
+	it "must accept a sole named size argument that is an Array" do
+	    rectangle = Rectangle.new size:[1,2]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.origin.must_equal Point[0,0]
+	    rectangle.height.must_equal 2
+	    rectangle.width.must_equal 1
+	end
+
+	it "must accept a sole named size argument that is a Size" do
+	    rectangle = Rectangle.new size:Size[1,2]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.origin.must_equal Point[0,0]
+	    rectangle.height.must_equal 2
+	    rectangle.width.must_equal 1
+	end
+
+	it "must accept named width and height arguments" do
+	    rectangle = Rectangle.new width:1, height:3
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 3
+	    rectangle.width.must_equal 1
+	end
+
+	it "must reject width or height by themselves" do
+	    -> { Rectangle.new height:1 }.must_raise ArgumentError
+	    -> { Rectangle.new width:1 }.must_raise ArgumentError
+	end
+    end
+
+    describe "comparison" do
+	it "must compare equal" do
+	    rectangle = Rectangle [1,2], [3,4]
+	    rectangle.must_equal Rectangle([1,2], [3, 4])
+	end
+    end
+
+    describe "inset" do
+	subject { Rectangle.new [0,0], [10,10] }
+
+	it "must inset equally" do
+	    subject.inset(1).must_equal Rectangle.new [1,1], [9,9]
+	end
+
+	it "must inset vertically and horizontally" do
+	    subject.inset(1,2).must_equal Rectangle.new [1,2], [9,8]
+	    subject.inset(x:1, y:2).must_equal Rectangle.new [1,2], [9,8]
+	end
+
+	it "must inset from individual sides" do
+	    subject.inset(1,2,3,4).must_equal Rectangle.new [2,3], [6,9]
+	    subject.inset(top:1, left:2, bottom:3, right:4).must_equal Rectangle.new [2,3], [6,9]
+	end
+    end
+
+    describe "properties" do
+	subject { Rectangle.new [1,2], [3,4] }
+	let(:rectangle) { Rectangle [1,2], [3,4] }
+
+	it "have a center point property" do
+	    rectangle.center.must_equal Point[2,3]
+	end
+
+	it "have a width property" do
+	    assert_equal(2, rectangle.width)
+	end
+
+	it "have a height property" do
+	    assert_equal(2, rectangle.height)
+	end
+
+	it "have an origin property" do
+	    assert_equal(Point[1,2], rectangle.origin)
+	end
+
+	it "have an edges property that returns 4 edges" do
+	    edges = rectangle.edges
+	    assert_equal(4, edges.size)
+	    edges.each {|edge| assert_kind_of(Geometry::Edge, edge)}
+	end
+
+	it "have a points property that returns 4 points" do
+	    points = rectangle.points
+	    assert_equal(4, points.size)
+	    points.each {|point| assert_kind_of(Geometry::Point, point)}
+	end
+
+	it "must have a bounds property that returns a Rectangle" do
+	    subject.bounds.must_equal Rectangle.new([1,2], [3,4])
+	end
+
+	it "must have a minmax property that returns the corners of the bounding rectangle" do
+	    subject.minmax.must_equal [Point[1,2], Point[3,4]]
+	end
+
+	it "must have a max property that returns the upper right corner of the bounding rectangle" do
+	    subject.max.must_equal Point[3,4]
+	end
+
+	it "must have a min property that returns the lower left corner of the bounding rectangle" do
+	    subject.min.must_equal Point[1,2]
+	end
+    end
+end