rays 0.1.11 → 0.1.16

data/test/test_painter_shape.rb

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestPainterShape < Test::Unit::TestCase
+
+  def color (*args)
+    Rays::Color.new *args
+  end
+
+  def image (fill = 1, stroke = 0, pixel_density = 1, &block)
+    Rays::Image.new(100, 100, Rays::RGBA, pixel_density).paint {|p|
+      p.fill   fill   > 0 ? color(fill)   : nil
+      p.stroke stroke > 0 ? color(stroke) : nil
+      p.instance_eval &block if block
+    }
+  end
+
+  def test_line ()
+    img = image(0, 1) {line 1, 1, 98, 98}
+    assert_equal 0, img[ 0,  0].a
+    assert_equal 1, img[ 1,  1].a
+    assert_equal 1, img[97, 97].a #img[98, 98].a
+    assert_equal 0, img[99, 99].a
+  end
+
+  def test_curve ()
+=begin
+    img = image(0, 1) {curve 1, 1, 98, 1, 98, 98, 1, 98}
+    assert_equal 0, img[ 0,  0].a
+    assert_equal 1, img[ 1,  1].a
+    assert_equal 0, img[98,  1].a
+    assert_equal 0, img[98, 50].a
+    assert_equal 0, img[98, 98].a
+    assert_equal 1, img[ 1, 97].a #img[ 1, 98].a
+    assert_equal 0, img[99, 99].a
+=end
+    assert_raise(ArgumentError) {image {curve}}
+    assert_raise(ArgumentError) {image {curve 0}}
+    assert_raise(ArgumentError) {image {curve 0, 1}}
+    assert_raise(ArgumentError) {image {curve 0, 1, 2}}
+    assert_raise(ArgumentError) {image {curve 0, 1, 2, 3}}
+    assert_raise(ArgumentError) {image {curve 0, 1, 2, 3, 4}}
+    assert_raise(ArgumentError) {image {curve 0, 1, 2, 3, 4, 5}}
+    assert_raise(ArgumentError) {image {curve 0, 1, 2, 3, 4, 5, 6}}
+    assert_nothing_raised       {image {curve 0, 1, 2, 3, 4, 5, 6, 7}}
+    assert_raise(ArgumentError) {image {curve 0, 1, 2, 3, 4, 5, 6, 7, 8}}
+  end
+
+  def test_bezier ()
+=begin
+    img = image(0, 1) {bezier 1, 1, 98, 1, 98, 98, 1, 98}
+    assert_equal 0, img[ 0,  0].a
+    assert_equal 1, img[ 1,  1].a
+    assert_equal 0, img[98,  1].a
+    assert_equal 0, img[98, 50].a
+    assert_equal 0, img[98, 98].a
+    assert_equal 1, img[ 1, 97].a #img[ 1, 98].a
+    assert_equal 0, img[99, 99].a
+=end
+    assert_raise(ArgumentError) {image {bezier}}
+    assert_raise(ArgumentError) {image {bezier 0}}
+    assert_raise(ArgumentError) {image {bezier 0, 1}}
+    assert_raise(ArgumentError) {image {bezier 0, 1, 2}}
+    assert_raise(ArgumentError) {image {bezier 0, 1, 2, 3}}
+    assert_raise(ArgumentError) {image {bezier 0, 1, 2, 3, 4}}
+    assert_raise(ArgumentError) {image {bezier 0, 1, 2, 3, 4, 5}}
+    assert_raise(ArgumentError) {image {bezier 0, 1, 2, 3, 4, 5, 6}}
+    assert_nothing_raised       {image {bezier 0, 1, 2, 3, 4, 5, 6, 7}}
+    assert_raise(ArgumentError) {image {bezier 0, 1, 2, 3, 4, 5, 6, 7, 8}}
+  end
+
+  def test_rect ()
+    img = image {rect 1, 1, 98, 98}
+    assert_equal 0, img[ 0,  0].a
+    assert_equal 1, img[ 1,  1].a
+    assert_equal 1, img[98, 98].a
+    assert_equal 0, img[99, 99].a
+  end
+
+  def test_rect_rounded ()
+    img = image {rect 1, 1, 98, 98, 10, 10, 10, 10}
+    assert_equal 0, img[ 0,  0].a
+    assert_equal 0, img[ 1,  1].a
+    assert_equal 1, img[10, 10].a
+    assert_equal 1, img[89, 89].a
+    assert_equal 0, img[98, 98].a
+    assert_equal 0, img[99, 99].a
+  end
+
+  def test_ellipse ()
+    img = image {ellipse 1, 1, 98, 98}
+    assert_equal 0, img[ 0,  0].a
+    assert_equal 1, img[50,  1].a
+    assert_equal 1, img[50, 50].a
+    assert_equal 1, img[ 1, 50].a
+    assert_equal 0, img[99, 99].a
+  end
+
+end# TestPainter

data/test/test_point.rb

@@ -18,6 +18,18 @@ class TestPoint < Test::Unit::TestCase
     assert_raise(ArgumentError) {point(1, 2, 3, 4)}
   end
 
+  def test_dup ()
+    o   = point
+    assert_equal point(0, 0, 0), o
+    o.x = 1
+    assert_equal point(1, 0, 0), o
+    x   = o.dup
+    assert_equal point(1, 0, 0), x
+    x.x = 2
+    assert_equal point(2, 0, 0), x
+    assert_equal point(1, 0, 0), o
+  end
+
   def test_get_xyz ()
     o = point 1, 2, 3
     assert_equal 1, o.x
@@ -95,6 +107,7 @@ class TestPoint < Test::Unit::TestCase
 
   def test_normal ()
     assert_equal point(1, 2, 3).normalize, point(1, 2, 3).normal
+    assert_raise(Rucy::NativeError) {point(0).normal}
   end
 
   def test_to_a ()
@@ -143,6 +156,10 @@ class TestPoint < Test::Unit::TestCase
     assert o > point(1, 2, 2)
   end
 
+  def test_negate ()
+    assert_equal point(-1, 2, -3), -point(1, -2, 3)
+  end
+
   def test_arithmetic_operations ()
     assert_equal point(11, 22, 33), point(10, 20, 30) + point(1, 2, 3)
     assert_equal point( 9, 18, 27), point(10, 20, 30) - point(1, 2, 3)
@@ -158,4 +175,16 @@ class TestPoint < Test::Unit::TestCase
     assert_equal point( 5, 10, 15), point(10, 20, 30) / 2
   end
 
+  def test_inspect ()
+    assert_equal "#<Rays::Point 1.0, 2.0, 3.0>", point(1, 2, 3).inspect
+  end
+
+  def test_dot ()
+    assert_equal 1*4 + 2*5 + 3*6, Rays::Point::dot(point(1, 2, 3), point(4, 5, 6))
+  end
+
+  def test_cross ()
+    assert_equal point(0, 0, 1), Rays::Point::cross(point(1, 0, 0), point(0, 1, 0))
+  end
+
 end# TestPoint

data/test/test_polygon.rb

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestPolygon < Test::Unit::TestCase
+
+  class Rays::Polygon
+    def dump ()
+      map {|l| l.map &:to_a}
+    end
+  end
+
+  def polygon (*args)
+    Rays::Polygon.new *args
+  end
+
+  def line (*args)
+    Rays::Polygon::Line.new *args
+  end
+
+  def polyline (*args)
+    Rays::Polyline.new *args
+  end
+
+  def point (*args)
+    Rays::Point.new *args
+  end
+
+  def bounds (*args)
+    Rays::Bounds.new *args
+  end
+
+  def rect (*args)
+    Rays::Polygon.rect *args
+  end
+
+  def assert_equal_polygon (poly1, poly2)
+    assert_equal *[poly1, poly2].map {|poly|
+      poly.dump.map {|l| l.map {|p| p.map &:round}}.map(&:sort).sort.flatten
+    }
+  end
+
+  def test_initialize ()
+    assert_equal [[[1, 2], [3, 4]]], polygon(   1, 2,     3, 4,  loop: false).dump
+    assert_equal [[[5, 6], [7, 8]]], polygon(  [5, 6],   [7, 8], loop: false).dump
+    assert_equal [[[1, 1], [2, 2]]], polygon(     [1],      [2], loop: false).dump
+    assert_equal [[[3, 3], [4, 4]]], polygon(point(3), point(4), loop: false).dump
+    assert_nothing_raised       {polygon(                  loop: true)}
+    assert_nothing_raised       {polygon(                  loop: false)}
+    assert_raise(ArgumentError) {polygon(1,                loop: true)}
+    assert_raise(ArgumentError) {polygon(1,                loop: false)}
+    assert_raise(ArgumentError) {polygon(1, 2,             loop: true)}
+    assert_nothing_raised       {polygon(1, 2,             loop: false)}
+    assert_raise(ArgumentError) {polygon(1, 2, 3,          loop: true)}
+    assert_raise(ArgumentError) {polygon(1, 2, 3,          loop: false)}
+    assert_raise(ArgumentError) {polygon(1, 2, 3, 4,       loop: true)}
+    assert_nothing_raised       {polygon(1, 2, 3, 4,       loop: false)}
+    assert_raise(ArgumentError) {polygon(1, 2, 3, 4, 5,    loop: true)}
+    assert_raise(ArgumentError) {polygon(1, 2, 3, 4, 5,    loop: false)}
+    assert_nothing_raised       {polygon(1, 2, 3, 4, 5, 6, loop: true)}
+    assert_nothing_raised       {polygon(1, 2, 3, 4, 5, 6, loop: false)}
+  end
+
+  def test_expand ()
+    polygon([10,10], [20,10], [30,20],          loop: false).expand(1).tap {|o|
+      assert_equal 1, o   .size
+      assert_equal 6, o[0].size
+    }
+    polygon([10,10], [20,10], [20,20], [10,20], loop: true) .expand(1).tap {|o|
+      assert_equal 1, o   .size
+      assert_equal 4, o[0].size
+    }
+  end
+
+  def test_transform_with_matrix ()
+    m = Rays::Matrix.translate 10, 10
+    assert_equal_polygon rect(20, 20, 50, 50), rect(10, 10, 50, 50).transform(m)
+
+    m = Rays::Matrix.scale 2
+    assert_equal_polygon rect(20, 20, 40, 40), rect(10, 10, 20, 20).transform(m)
+
+    m = Rays::Matrix.rotate 90
+    assert_equal_polygon rect(-10, 0, 10, 10), rect(0, 0, 10, 10).transform(m)
+  end
+
+  def test_transform_block ()
+    o = rect(0, 0, 100, 100) - rect(10, 10, 50, 50)
+    assert_equal 2, o.size
+
+    o.transform {|lines|
+      lines.map {|l| l.transform Rays::Matrix.translate 10, 10}
+    }.tap {|x|
+      assert_equal_polygon (rect(10, 10, 100, 100) - rect(20, 20, 50, 50)), x
+    }
+
+    o.transform {|lines|
+      lines.reject {|l| l.to_a.include? point(10, 10)}
+    }.tap {|x|
+      assert_equal 1, x.size
+      assert_equal 2, o.size
+    }
+
+    o.transform {|lines|
+      lines.reject {|l| l.to_a.include? point(10, 10)}
+    }.tap {|x|
+      assert_equal 1, x.size
+      assert_equal 2, o.size
+    }
+
+    o.transform {|lines|
+      lines + [line(1, 2, 3, 4, 5, 6)]
+    }.tap {|x|
+      assert_equal 3, x.size
+      assert_equal 2, o.size
+    }
+  end
+
+  def test_intersects ()
+    assert     rect(10, 10, 20, 20).intersects(rect 20, 20, 20, 20)
+    assert_not rect(10, 10, 20, 20).intersects(rect 40, 40, 20, 20)
+  end
+
+  def test_bounds ()
+    assert_equal bounds(10, 20, 0, 20, 10, 0), polygon(10, 20, 30, 20, 20, 30).bounds
+
+    assert     polygon(10, 20, 30, 20, 20, 30).bounds.valid?
+    assert_not polygon()                      .bounds.valid?
+  end
+
+  def test_loop ()
+    assert_equal true,  polygon(1, 2, 3, 4, 5, 6             ).first.loop?
+    assert_equal true,  polygon(1, 2, 3, 4, 5, 6, loop: true ).first.loop?
+    assert_equal false, polygon(1, 2, 3, 4, 5, 6, loop: false).first.loop?
+  end
+
+  def test_size ()
+    assert_equal 0, polygon(                             ).size
+    assert_equal 1, polygon(1, 2, 3, 4,       loop: false).size
+    assert_equal 1, polygon(1, 2, 3, 4, 5, 6, loop: false).size
+    assert_equal 2, (rect(0, 0, 5, 5) | rect(10, 0, 5, 5)).size
+  end
+
+  def test_empty? ()
+    assert_equal true,  polygon(                ).empty?
+    assert_equal false, polygon(1, 2, 3, 4, 5, 6).empty?
+  end
+
+  def test_index ()
+    o1 = rect  0, 0, 10, 10
+    o2 = rect 20, 0, 10, 10
+    o3 = rect 40, 0, 10, 10
+    o  = o1 | o2 | o3
+    assert_not_nil o[ 0]
+    assert_not_nil o[ 1]
+    assert_not_nil o[-1]
+    assert_raise(IndexError) {o[ 3]}
+    assert_raise(IndexError) {o[-4]}
+  end
+
+  def test_sub ()
+    rect10 = rect 0, 0, 10, 10
+
+    o = rect10 - rect(5, 0, 10, 10)
+    assert_equal_polygon rect(0, 0, 5, 10), o
+
+    o = rect10 - rect(5, 0, 10, 10) - rect(0, 0, 2, 10)
+    assert_equal_polygon rect(2, 0, 3, 10), o
+
+    o = rect10 - [rect(5, 0, 10, 10), rect(0, 0, 3, 10)]
+    assert_equal_polygon rect(3, 0, 2, 10), o
+
+    assert_equal_polygon rect10,    rect10    - polygon()
+    assert_equal_polygon polygon(), polygon() - rect10
+    assert_equal_polygon rect10,    rect10    - []
+    assert_equal_polygon polygon(), rect10    - rect10
+  end
+
+  def test_and ()
+    rect10 = rect 0, 0, 10, 10
+
+    o = rect10 & rect(5, 0, 10, 10)
+    assert_equal_polygon rect(5, 0, 5, 10), o
+
+    o = rect10 & rect(5, 0, 10, 10) & rect(0, 5, 10, 10)
+    assert_equal_polygon rect(5, 5, 5, 5), o
+
+    o = rect10 & [rect(5, 0, 10, 10), rect(0, 6, 10, 10)]
+    assert_equal_polygon rect(5, 6, 5, 4), o
+
+    assert_equal_polygon polygon(), rect10    & polygon()
+    assert_equal_polygon polygon(), polygon() & rect10
+    assert_equal_polygon rect10,    rect10    & []
+    assert_equal_polygon rect10,    rect10    & rect10
+  end
+
+  def test_or ()
+    rect10 = rect 0, 0, 10, 10
+
+    o = rect10 | rect(5, 0, 10, 10)
+    assert_equal_polygon rect(0, 0, 15, 10), o
+
+    o = rect10 | rect(5, 0, 10, 10) | rect(-5, 0, 10, 10)
+    assert_equal_polygon rect(-5, 0, 20, 10), o
+
+    o = rect10 | [rect(5, 0, 10, 10), rect(-6, 0, 10, 10)]
+    assert_equal_polygon rect(-6, 0, 21, 10), o
+
+    assert_equal_polygon rect10, rect10    | polygon()
+    assert_equal_polygon rect10, polygon() | rect10
+    assert_equal_polygon rect10, rect10    | []
+    assert_equal_polygon rect10, rect10    | rect10
+  end
+
+  def test_xor ()
+    rect10 = rect 0, 0, 10, 10
+
+    o = rect10 ^ rect(5, 0, 10, 10)
+    assert_equal_polygon rect(0, 0, 5, 10) | rect(10, 0, 5, 10), o
+
+    o = rect10 ^ rect(5, 0, 10, 10) ^ rect(0, 0, 15, 5)
+    assert_equal_polygon rect(0, 5, 5, 5) | rect(5, 0, 5, 5) | rect(10, 5, 5, 5), o
+
+    o = rect10 ^ [rect(5, 0, 10, 10), rect(0, 0, 15, 6)]
+    assert_equal_polygon rect(0, 6, 5, 4) | rect(5, 0, 5, 6) | rect(10, 6, 5, 4), o
+
+    assert_equal_polygon rect10,    rect10    ^ polygon()
+    assert_equal_polygon rect10,    polygon() ^ rect10
+    assert_equal_polygon rect10,    rect10    ^ []
+    assert_equal_polygon polygon(), rect10    ^ rect10
+  end
+
+end# TestPolygon

data/test/test_polygon_line.rb

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestPolygonLine < Test::Unit::TestCase
+
+  class Rays::Polygon::Line
+    def dump ()
+      map &:to_a
+    end
+
+    def loop_hole ()
+      [loop?, hole?]
+    end
+  end
+
+  def line (*args)
+    Rays::Polygon::Line.new *args
+  end
+
+  def point (*args)
+    Rays::Point.new *args
+  end
+
+  def rect (*args)
+    Rays::Polygon.rect *args
+  end
+
+  def test_initialize ()
+    assert_equal [[1, 2], [3, 4], [5, 6]], line(   1, 2,     3, 4 ,    5, 6 ).dump
+    assert_equal [[1, 2], [3, 4], [5, 6]], line(  [1, 2],   [3, 4],   [5, 6]).dump
+    assert_equal [[1, 1], [2, 2], [3, 3]], line(     [1],      [2],      [3]).dump
+    assert_equal [[1, 1], [2, 2], [3, 3]], line(point(1), point(2), point(3)).dump
+
+    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6                          ).loop_hole
+    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6, loop: true              ).loop_hole
+    assert_equal [false, false],  line(1, 2, 3, 4, 5, 6, loop: false             ).loop_hole
+    assert_equal [true,  true ],  line(1, 2, 3, 4, 5, 6,              hole: true ).loop_hole
+    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6,              hole: false).loop_hole
+    assert_equal [true,  true ],  line(1, 2, 3, 4, 5, 6, loop: true,  hole: true ).loop_hole
+    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6, loop: true,  hole: false).loop_hole
+    assert_raise(ArgumentError)  {line(1, 2, 3, 4, 5, 6, loop: false, hole: true ).loop_hole}
+    assert_equal [false, false],  line(1, 2, 3, 4, 5, 6, loop: false, hole: false).loop_hole
+
+    assert_raise(ArgumentError) {line(                  loop: true,  hole: true )}
+    assert_nothing_raised       {line(                  loop: true,  hole: false)}
+    assert_raise(ArgumentError) {line(                  loop: false, hole: true )}
+    assert_nothing_raised       {line(                  loop: false, hole: false)}
+    assert_raise(ArgumentError) {line(1,                loop: true,  hole: true )}
+    assert_raise(ArgumentError) {line(1,                loop: true,  hole: false)}
+    assert_raise(ArgumentError) {line(1,                loop: false, hole: true )}
+    assert_raise(ArgumentError) {line(1,                loop: false, hole: false)}
+    assert_raise(ArgumentError) {line(1, 2,             loop: true,  hole: true )}
+    assert_raise(ArgumentError) {line(1, 2,             loop: true,  hole: false)}
+    assert_raise(ArgumentError) {line(1, 2,             loop: false, hole: true )}
+    assert_nothing_raised       {line(1, 2,             loop: false, hole: false)}
+    assert_raise(ArgumentError) {line(1, 2, 3,          loop: true,  hole: true )}
+    assert_raise(ArgumentError) {line(1, 2, 3,          loop: true,  hole: false)}
+    assert_raise(ArgumentError) {line(1, 2, 3,          loop: false, hole: true )}
+    assert_raise(ArgumentError) {line(1, 2, 3,          loop: false, hole: false)}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4,       loop: true,  hole: true )}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4,       loop: true,  hole: false)}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4,       loop: false, hole: true )}
+    assert_nothing_raised       {line(1, 2, 3, 4,       loop: false, hole: false)}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: true,  hole: true )}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: true,  hole: false)}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: false, hole: true )}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: false, hole: false)}
+    assert_nothing_raised       {line(1, 2, 3, 4, 5, 6, loop: true,  hole: true )}
+    assert_nothing_raised       {line(1, 2, 3, 4, 5, 6, loop: true,  hole: false)}
+    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5, 6, loop: false, hole: true )}
+    assert_nothing_raised       {line(1, 2, 3, 4, 5, 6, loop: false, hole: false)}
+  end
+
+  def test_transform_with_materix ()
+    m = Rays::Matrix.translate 100, 200
+    line([10,10], [20,20], loop: false).transform(m).tap {|o|
+      assert_equal [[110,210], [120,220]], o.dump
+    }
+
+    m = Rays::Matrix.scale 2
+    line([10,10], [20,20], loop: false).transform(m).tap {|o|
+      assert_equal [[20,20],   [40,40]],   o.dump
+    }
+
+    m = Rays::Matrix.rotate 90
+    line([10,10], [20,20], loop: false).transform(m).tap {|o|
+      assert_equal [[-10,10],  [-20,20]],  o.dump
+    }
+  end
+
+  def test_transform_with_block ()
+    line([10,10], [20,20],          loop: false).transform {|points|
+      points.map {|p| p + [10, 20]}
+    }.tap {|o|
+      assert_equal [[20,30], [30,40]],          o.dump
+    }
+
+    line([10,10], [20,20], [30,30], loop: false).transform {|points|
+      points.reject {|p| p == point(20, 20)}
+    }.tap {|o|
+      assert_equal [[10,10], [30,30]],          o.dump
+    }
+
+    line([10,10], [20,20],          loop: false).transform {|points|
+      points + [[30, 30]]
+    }.tap {|o|
+      assert_equal [[10,10], [20,20], [30,30]], o.dump
+    }
+
+    points = [1, 2, 3, 4, 5, 6]
+    line(*points,   loop: false, hole: false).transform(loop: true              ).tap {|o|
+      assert_equal points, o.dump.flatten
+      assert_equal [true,  false], o.loop_hole
+    }
+    assert_raise(ArgumentError) {
+      line(*points, loop: false, hole: false).transform(             hole: true )
+    }
+    assert_raise(ArgumentError) {
+      line(*points, loop: false, hole: false).transform(loop: false, hole: true )
+    }
+    line(*points,   loop: false, hole: false).transform(loop: true,  hole: true ).tap {|o|
+      assert_equal points, o.dump.flatten
+      assert_equal [true,  true ], o.loop_hole
+    }
+    line(*points,   loop: true,  hole: false).transform(loop: false             ).tap {|o|
+      assert_equal points, o.dump.flatten
+      assert_equal [false, false], o.loop_hole
+    }
+    line(*points,   loop: true,  hole: false).transform(             hole: true ).tap {|o|
+      assert_equal points, o.dump.flatten
+      assert_equal [true,  true ], o.loop_hole
+    }
+    assert_raise(ArgumentError) {
+      line(*points, loop: true,  hole: false).transform(loop: false, hole: true )
+    }
+    assert_raise(ArgumentError) {
+      line(*points, loop: true,  hole: true ).transform(loop: false             )
+    }
+    line(*points,   loop: true,  hole: true ).transform(             hole: false).tap {|o|
+      assert_equal points, o.dump.flatten
+      assert_equal [true,  false], o.loop_hole
+    }
+    line(*points,   loop: true,  hole: true ).transform(loop: false, hole: false).tap {|o|
+      assert_equal points, o.dump.flatten
+      assert_equal [false, false], o.loop_hole
+    }
+  end
+
+  def test_hole ()
+    (rect(0, 0, 10, 10) - rect(1, 1, 2, 2)).tap {|o|
+      assert_equal 1, o.select {|line| line.hole?}.size
+    }
+    (rect(0, 0, 10, 10) - rect(100, 1, 2, 2)).tap {|o|
+      assert_equal 0, o.select {|line| line.hole?}.size
+    }
+  end
+
+  def test_inspect ()
+    assert_equal(
+      "#<Rays::Polygon::Line [1.0, 2.0], [3.0, 4.0], [5.0, 6.0], loop: true, hole: false>",
+      line(1, 2, 3, 4, 5, 6).inspect)
+  end
+
+end# TestPolygonLine