geometry 6.2 → 6.3

data/test/geometry/point_one.rb

@@ -0,0 +1,199 @@
+require 'minitest/autorun'
+require 'geometry/point_one'
+
+describe Geometry::PointOne do
+    subject { Geometry::PointOne.new }
+    let(:one) { Geometry::PointOne.new }
+
+    describe 'arithmetic' do
+	let(:left) { Point[1,2] }
+	let(:right) { Point[3,4] }
+
+	it 'must pretend to be a Point' do
+	    subject.is_a?(Point).must_equal true
+	    subject.kind_of?(Point).must_equal true
+
+	    subject.is_a?(Geometry::PointOne).must_equal true
+	    subject.kind_of?(Geometry::PointOne).must_equal true
+
+	    subject.instance_of?(Point).must_equal false
+	    subject.instance_of?(Geometry::PointOne).must_equal true
+	end
+
+	it 'must have +@' do
+	    (+one).must_be :eql?, 1
+	    (+one).must_be_instance_of(Geometry::PointOne)
+	end
+
+	it 'must have unary negation' do
+	    (-one).must_be :eql?, -1
+#	    (-one).must_be_instance_of(Geometry::PointOne)
+	end
+
+	describe 'Accessors' do
+	    it 'must return 1 for array access' do
+		one[3].must_equal 1
+	    end
+
+	    it 'must return 1 for named element access' do
+		one.x.must_equal 1
+		one.y.must_equal 1
+		one.z.must_equal 1
+	    end
+	end
+
+	it 'must add a number' do
+	    (one + 3).must_equal 4
+	    (3 + one).must_equal 4
+	end
+
+	it 'return a Point when adding two Points' do
+	    (one + right).must_be_kind_of Point
+	    (left + one).must_be_kind_of Point
+	end
+
+	it 'must return an Array when adding an array' do
+	    (one + [5,6]).must_equal [6, 7]
+	    ([5,6] + one).must_equal [5,6]
+	end
+
+	it 'must return a Point when adding a Size' do
+	    (one + Size[5,6]).must_be_instance_of(Point)
+	    (one + Size[5,6]).must_equal Point[6,7]
+	end
+
+	describe 'when subtracting' do
+	    it 'must subtract a number' do
+		(one - 3).must_equal -2
+		(3 - one).must_equal 2
+	    end
+
+	    it 'return a Point when subtracting two Points' do
+		(one - right).must_equal Point[-2, -3]
+		(left - one).must_equal Point[0, 1]
+	    end
+
+	    it 'must return a Point when subtracting an array' do
+		(one - [5,6]).must_equal [-4, -5]
+#		([5,6] - one).must_equal [4,5]
+	    end
+
+	    it 'must return a Point when subtracting a Size' do
+		(one - Size[5,6]).must_be_instance_of(Point)
+		(one - Size[5,6]).must_equal Point[-4,-5]
+	    end
+	end
+
+	it 'must multiply by a scalar' do
+	    (one * 3).must_equal 3
+	    (one * 3.0).must_equal 3.0
+	end
+
+	it 'must refuse to multiply by a Point' do
+	    -> { one * Point[1, 2] }.must_raise Geometry::OperationNotDefined
+	end
+
+	it 'must refuse to multiply by a Vector' do
+	    -> { one * Vector[2, 3] }.must_raise Geometry::OperationNotDefined
+	end
+
+	it 'must divide by a scalar' do
+	    (one / 3).must_equal 1/3
+	    (one / 4.0).must_equal 1/4.0
+	end
+
+	it 'must raise an exception when divided by 0' do
+	    -> { one / 0 }.must_raise ZeroDivisionError
+	end
+
+	describe 'division' do
+	    it 'must raise an exception for Points' do
+		lambda { one / Point[1,2] }.must_raise Geometry::OperationNotDefined
+	    end
+
+	    it 'must raise an exception for Vectors' do
+		lambda { one / Vector[1,2] }.must_raise Geometry::OperationNotDefined
+	    end
+	end
+    end
+
+    describe 'coercion' do
+	it 'must coerce Arrays into Points' do
+	    one.coerce([3,4]).must_equal [Point[3,4], Point[1, 1]]
+	end
+
+	it 'must coerce Vectors into Vectors' do
+	    one.coerce(Vector[3,4]).must_equal [Vector[3,4], Vector[1, 1]]
+	end
+
+	it 'must coerce Points into Points' do
+	    one.coerce(Point[5,6]).must_equal [Point[5,6], Point[1, 1]]
+	end
+    end
+
+    describe 'comparison' do
+	subject { Geometry::PointOne.new }
+
+	it 'must be equal to 1 and 1.0' do
+	    one.must_be :eql?, 1
+	    one.must_be :eql?, 1.0
+	end
+
+	it 'must not be equal to a non-one number' do
+	    0.wont_equal one
+	    3.14.wont_equal one
+	end
+
+	it 'must be equal to an Array of ones' do
+	    one.must_be :==, [1,1]
+	    one.must_be :eql?, [1,1]
+	    one.must_be :===, [1,1]
+	    [1, 1].must_equal one
+	    one.must_equal [1, 1]
+	end
+
+	it 'must not be equal to a non-one Array' do
+	    one.wont_equal [3, 2, 1]
+	    [3, 2, 1].wont_equal one
+	end
+
+	it 'must not be equal to a Point at the origin' do
+	    one.wont_be :==, Point[0,0]
+	    one.wont_be :eql?, Point[0,0]
+	    one.wont_be :===, Point[0,0]
+	    Point[0,0].wont_equal one
+	    subject.wont_equal Point[0,0]
+	end
+
+	it 'must not be equal to a Point not at the origin' do
+	    one.wont_equal Point[3,2]
+	    Point[3,2].wont_equal one
+	end
+
+	it 'must be equal to a Point of ones' do
+	    one.must_be :==, Point[1,1]
+	    one.must_be :eql?, Point[1,1]
+	    one.must_be :===, Point[1,1]
+	    Point[1,1].must_equal one
+	    one.must_equal Point[1,1]
+	end
+
+	it 'must be equal to an Vector of ones' do
+	    one.must_be :eql?, Vector[1, 1]
+	    Vector[1, 1].must_equal one
+	end
+	
+	it 'must not be equal to a non-one Vector' do
+	    one.wont_equal Vector[3,2]
+	    Vector[3,2].wont_equal one
+	end
+    end
+
+    describe 'when enumerating' do
+	it 'must have a first method' do
+	    one.first.must_equal 1
+	    one.first(1).must_equal [1]
+	    one.first(5).must_equal [1,1,1,1,1]
+	end
+    end
+end

data/test/geometry/point_zero.rb

@@ -2,12 +2,24 @@ require 'minitest/autorun'
 require 'geometry/point_zero'
 
 describe Geometry::PointZero do
+    subject { Geometry::PointZero.new }
     let(:zero) { Geometry::PointZero.new }
 
     describe "arithmetic" do
 	let(:left) { Point[1,2] }
 	let(:right) { Point[3,4] }
-	
+
+	it 'must pretend to be a Point' do
+	    subject.is_a?(Point).must_equal true
+	    subject.kind_of?(Point).must_equal true
+
+	    subject.is_a?(PointZero).must_equal true
+	    subject.kind_of?(PointZero).must_equal true
+
+	    subject.instance_of?(Point).must_equal false
+	    subject.instance_of?(PointZero).must_equal true
+	end
+
 	it "must have +@" do
 	    (+zero).must_be :eql?, 0
 	    (+zero).must_be_instance_of(Geometry::PointZero)
@@ -31,8 +43,9 @@ describe Geometry::PointZero do
 	end
 
 	describe "when adding" do
-	    it "must return a number" do
+	    it "must return a PointIso when adding a number" do
 		(zero + 3).must_equal 3
+		(zero + 3).must_be_instance_of Geometry::PointIso
 		(3 + zero).must_equal 3
 	    end
 
@@ -174,4 +187,12 @@ describe Geometry::PointZero do
 	    Vector[3,2].wont_equal zero
 	end
     end
+
+    describe 'when enumerating' do
+	it 'must have a first method' do
+	    subject.first.must_equal 0
+	    subject.first(1).must_equal [0]
+	    subject.first(5).must_equal [0,0,0,0,0]
+	end
+    end
 end

data/test/geometry/polyline.rb

@@ -22,6 +22,10 @@ describe Geometry::Polyline do
 	polyline.vertices.count.must_equal 4
     end
 
+    it 'must have a points attribute' do
+	unit_square.points.must_equal [Point[0,0], Point[1,0], Point[1,1], Point[0,1]]
+    end
+
     it 'must know the max' do
 	unit_square.max.must_equal Point[1,1]
     end

data/test/geometry/rectangle.rb

@@ -111,6 +111,10 @@ describe Geometry::Rectangle do
 	    rectangle.center.must_equal Point[2,3]
 	end
 
+	it 'must always be closed' do
+	    subject.closed?.must_equal true
+	end
+
 	it "have a width property" do
 	    assert_equal(2, rectangle.width)
 	end

data/test/geometry/regular_polygon.rb

@@ -4,7 +4,13 @@ require 'geometry/regular_polygon'
 describe Geometry::RegularPolygon do
     RegularPolygon = Geometry::RegularPolygon
 
-    describe "when constructed with named center and radius arguments" do
+    subject { RegularPolygon.new sides:4, center:[1,2], radius:3 }
+
+    it 'must always be closed' do
+	subject.closed?.must_equal true
+    end
+
+    describe 'when constructed with a center and circumradius' do
 	let(:polygon) { RegularPolygon.new sides:4, center:[1,2], radius:3 }
 	subject { RegularPolygon.new sides:4, center:[1,2], radius:3 }
 
@@ -33,16 +39,19 @@ describe Geometry::RegularPolygon do
 		subject.vertices.must_equal [Point[4.0, 2.0], Point[1.0000000000000002, 5.0], Point[-2.0, 2.0000000000000004], Point[0.9999999999999994, -1.0]]
 	    end
 	end
+
+	it 'must have an indiameter' do
+	    subject.indiameter.must_be_close_to 4.242
+	end
+
+	it 'must have an inradius' do
+	    subject.inradius.must_be_close_to 2.121
+	end
     end
 
     describe "when constructed with a center and diameter" do
 	let(:polygon) { RegularPolygon.new sides:4, center:[1,2], diameter:4 }
 
-	it "must be a DiameterRegularPolygon" do
-	    polygon.must_be_instance_of(Geometry::DiameterRegularPolygon)
-	    polygon.must_be_kind_of(RegularPolygon)
-	end
-
 	it "must have the correct number of sides" do
 	    polygon.edge_count.must_equal 4
 	end
@@ -67,11 +76,6 @@ describe Geometry::RegularPolygon do
     describe "when constructed with a diameter and no center" do
 	let(:polygon) { RegularPolygon.new sides:4, diameter:4 }
 
-	it "must be a DiameterRegularPolygon" do
-	    polygon.must_be_instance_of(Geometry::DiameterRegularPolygon)
-	    polygon.must_be_kind_of(RegularPolygon)
-	end
-
 	it "must have the correct number of sides" do
 	    polygon.edge_count.must_equal 4
 	end
@@ -89,6 +93,41 @@ describe Geometry::RegularPolygon do
 	end
     end
 
+    describe 'when constructed with an indiameter and center' do
+	subject { RegularPolygon.new sides:6, indiameter:4 }
+
+	it 'must have a circumdiameter' do
+	    subject.diameter.must_be_close_to 4.618
+	end
+
+	it 'must have a circumradius' do
+	    subject.circumradius.must_be_close_to 2.309
+	end
+
+	it 'must have an indiameter' do
+	    subject.indiameter.must_be_close_to 4
+	end
+
+	it 'must have an inradius' do
+	    subject.inradius.must_be_close_to 2
+	end
+    end
+
+    describe 'when constructed with an inradius and center' do
+	subject { RegularPolygon.new sides:6, inradius:4 }
+
+	it 'must have a circumradius' do
+	    subject.circumradius.must_be_close_to 4.618
+	end
+
+	it 'must have points' do
+	    expected_points = [Point[4.618, 0], Point[2.309, 4], Point[-2.309, 4], Point[-4.618, 0], Point[-2.309, -4], Point[2.309, -4]]
+	    subject.points.zip(expected_points) do |point0, point1|
+		point0.to_a.zip(point1.to_a) {|a, b| a.must_be_close_to b }
+	    end
+	end
+    end
+
     describe "properties" do
 	subject { RegularPolygon.new sides:6, diameter:4 }
 
@@ -101,6 +140,13 @@ describe Geometry::RegularPolygon do
 	    end
 	end
 
+	it 'must have points' do
+	    expected_points = [Point[2, 0], Point[1, 1.732], Point[-1, 1.732], Point[-2, 0], Point[-1, -1.732], Point[1, -1.732]]
+	    subject.points.zip(expected_points) do |point0, point1|
+		point0.to_a.zip(point1.to_a) {|a, b| a.must_be_close_to b }
+	    end
+	end
+
 	it "must have a bounds property that returns a Rectangle" do
 	    subject.bounds.must_equal Rectangle.new([-2,-2], [2,2])
 	end

data/test/geometry/rotation.rb

@@ -93,6 +93,8 @@ describe Geometry::Rotation do
     end
 
     describe "when transforming a Point" do
+	subject { Rotation.new(angle:Math::PI/2) }
+
 	describe "when no rotation is set" do
 	    it "must return the Point" do
 		Rotation.new.transform(Point[1,0]).must_equal Point[1,0]
@@ -104,5 +106,9 @@ describe Geometry::Rotation do
 	    rotated_point.x.must_be_close_to 0
 	    rotated_point.y.must_be_close_to 1
 	end
+
+	it 'must transform a PointZero' do
+	    subject.transform(Point.zero).must_equal Point.zero
+	end
     end
 end

data/test/geometry/size.rb

@@ -41,12 +41,21 @@ describe Geometry::Size do
 	end
     end
 
-    it "allow indexed element access" do
-	size = Geometry::Size[5,6]
-	assert_equal(2, size.size)
-	assert_equal(5, size[0])
-	assert_equal(6, size[1])
+    describe 'when array access' do
+	it 'must allow indexed access' do
+	    size = Geometry::Size[5,6]
+	    size.size.must_equal 2
+	    size[0].must_equal 5
+	    size[1].must_equal 6
+	end
+
+	it 'must slize with a start index and a length' do
+	    size = Geometry::Size[5, 6, 7]
+	    slice = size[1,2]
+	    slice.length.must_equal 2
+	end
     end
+
     it "allow named element access" do
 	size = Geometry::Size[5,6,7]
 	assert_equal(3, size.size)
@@ -99,9 +108,15 @@ describe Geometry::Size do
 
     it 'must inset with horizontal and vertical insets' do
 	subject.inset(4).must_equal Geometry::Size[6, 6]
-	subject.inset(2,3).must_equal Geometry::Size[8, 7]
-	subject.inset(x:2, y:3).must_equal Geometry::Size[8, 7]
+	subject.inset(2,3).must_equal Geometry::Size[6, 4]
+	subject.inset(x:2, y:3).must_equal Geometry::Size[6, 4]
+    end
+
+    it 'must inset with left and top' do
 	subject.inset(left:2, top:3).must_equal Geometry::Size[8, 7]
+    end
+
+    it 'must inset with right and bottom' do
 	subject.inset(right:2, bottom:3).must_equal Geometry::Size[8, 7]
     end
 
@@ -111,13 +126,19 @@ describe Geometry::Size do
 
     it 'must outset' do
 	subject.outset(4).must_equal Geometry::Size[14, 14]
-	subject.outset(2,3).must_equal Geometry::Size[12, 13]
-	subject.outset(x:2, y:3).must_equal Geometry::Size[12, 13]
+	subject.outset(2,3).must_equal Geometry::Size[14, 16]
+	subject.outset(x:2, y:3).must_equal Geometry::Size[14, 16]
+    end
+
+    it 'must outset with left and top' do
 	subject.outset(left:2, top:3).must_equal Geometry::Size[12, 13]
+    end
+
+    it 'must outset with right and bottom' do
 	subject.outset(right:2, bottom:3).must_equal Geometry::Size[12, 13]
     end
 
-    it 'must inset with insets for top, left, bottom, right' do
+    it 'must outset with insets for top, left, bottom, right' do
 	subject.outset(top:1, left:2, bottom:3, right:4).must_equal Geometry::Size[16, 14]
     end
 end