rays 0.1.11 → 0.1.16

data/test/test_color.rb

@@ -10,12 +10,12 @@ class TestColor < Test::Unit::TestCase
     Rays::Color.new *args
   end
 
-  def color8 (r, g, b, a, div = 255)
+  def color8 (r, g, b, a = 255, div = 255)
     color *[r, g, b, a].map {|n| n / div.to_f}
   end
 
-  def to_color (*args)
-    Rays::Color.color *args
+  def hsv (*args)
+    Rays::Color.hsv *args
   end
 
   def test_initialize ()
@@ -28,22 +28,34 @@ class TestColor < Test::Unit::TestCase
     assert_raise(ArgumentError) {color(1, 2, 3, 4, 5)}
   end
 
-  def test_color ()
-    assert_equal color(0, 0, 0, 1), to_color('#000')
-    assert_equal color(0, 0, 0, 1), to_color('#000000')
-    assert_equal color(0, 0, 0, 0), to_color('#0000')
-    assert_equal color(0, 0, 0, 0), to_color('#00000000')
-    assert_equal color8(0x01, 0x23, 0x45, 0x67), to_color('#01234567')
-    assert_equal color8(0x89, 0xab, 0xcd, 0xef), to_color('#89abcdef')
-    assert_equal color8(0x0, 0x2, 0x4, 0x6, 15), to_color('#0246')
-    assert_equal color8(0x9, 0xb, 0xd, 0xf, 15), to_color('#9bdf')
-    assert_equal color(0, 0, 0, 1), to_color(' #000 ')
-    assert_raise(ArgumentError) {to_color '#'}
-    assert_raise(ArgumentError) {to_color '000'}
-    assert_raise(ArgumentError) {to_color '#0'}
-    assert_raise(ArgumentError) {to_color '#00'}
-    assert_raise(ArgumentError) {to_color '#00000'}
-    assert_raise(ArgumentError) {to_color '#0000000'}
+  def test_initialize_with_string ()
+    assert_equal color(0, 0, 0, 1), color('#000')
+    assert_equal color(0, 0, 0, 1), color('#000000')
+    assert_equal color(0, 0, 0, 0), color('#0000')
+    assert_equal color(0, 0, 0, 0), color('#00000000')
+    assert_equal color8(0x01, 0x23, 0x45, 0x67), color('#01234567')
+    assert_equal color8(0x89, 0xab, 0xcd, 0xef), color('#89abcdef')
+    assert_equal color8(0x0, 0x2, 0x4, 0x6, 15), color('#0246')
+    assert_equal color8(0x9, 0xb, 0xd, 0xf, 15), color('#9bdf')
+    assert_equal color(0, 0, 0, 1), color(' #000 ')
+    assert_raise(ArgumentError) {color '#'}
+    assert_raise(ArgumentError) {color '000'}
+    assert_raise(ArgumentError) {color '#0'}
+    assert_raise(ArgumentError) {color '#00'}
+    assert_raise(ArgumentError) {color '#00000'}
+    assert_raise(ArgumentError) {color '#0000000'}
+  end
+
+  def test_dup ()
+    o     = color
+    assert_equal color(0, 0, 0), o
+    o.red = 1
+    assert_equal color(1, 0, 0), o
+    x     = o.dup
+    assert_equal color(1, 0, 0), x
+    x.red = 2
+    assert_equal color(2, 0, 0), x
+    assert_equal color(1, 0, 0), o
   end
 
   def test_get_rgb ()
@@ -112,4 +124,32 @@ class TestColor < Test::Unit::TestCase
     assert o > color(1, 2, 3, 3)
   end
 
+  def test_hsv_hue ()
+    assert_equal color(0.5, 0, 1), hsv(-0.25, 1, 1)
+    assert_equal color(1,   0, 0), hsv( 0,    1, 1)
+    assert_equal color(0.5, 1, 0), hsv( 0.25, 1, 1)
+    assert_equal color(0,   1, 1), hsv( 0.5,  1, 1)
+    assert_equal color(0.5, 0, 1), hsv( 0.75, 1, 1)
+    assert_equal color(1,   0, 0), hsv( 1,    1, 1)
+    assert_equal color(0.5, 1, 0), hsv( 1.25, 1, 1)
+  end
+
+  def test_hsv_saturation ()
+    assert_equal color(1, 1,   1),   hsv(1, 0,   1)
+    assert_equal color(1, 0.5, 0.5), hsv(1, 0.5, 1)
+    assert_equal color(1, 0,   0),   hsv(1, 1,   1)
+  end
+
+  def test_hsv_value ()
+    assert_equal color(0,   0,   0), hsv(1, 1, 0)
+    assert_equal color(0.5, 0,   0), hsv(1, 1, 0.5)
+    assert_equal color(1,   0,   0), hsv(1, 1, 1)
+  end
+
+  def test_hsv_alpha ()
+    assert_equal color(1, 0, 0, 0),   hsv(1, 1, 1, 0)
+    assert_equal color(1, 0, 0, 0.5), hsv(1, 1, 1, 0.5)
+    assert_equal color(1, 0, 0, 1),   hsv(1, 1, 1, 1)
+  end
+
 end# TestColor

data/test/test_color_space.rb

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestColorSpace < Test::Unit::TestCase
+
+  def cs (*args)
+    Rays::ColorSpace.new *args
+  end
+
+  TYPES = %w[
+    gray alpha
+     rgb         bgr
+     rgba        bgra
+     rgbx        bgrx
+    argb        abgr
+    xrgb        xbgr
+     rgb_float   bgr_float
+     rgba_float  bgra_float
+    argb_float  abgr_float
+  ]
+
+  TYPES.each do |type|
+    define_method type do
+      cs type
+    end
+  end
+
+  alias  rgb_f   rgb_float
+  alias  rgba_f  rgba_float
+  alias argb_f  argb_float
+  alias  bgr_f   bgr_float
+  alias  bgra_f  bgra_float
+  alias abgr_f  abgr_float
+
+  def all ()
+    [
+      gray, alpha,
+      rgb, bgr, rgba, bgra, rgbx, bgrx, argb, abgr, xrgb, xbgr,
+      rgb_f, bgr_f, rgba_f, bgra_f, argb_f, abgr_f
+    ]
+  end
+
+  def test_gray? ()
+    grays  = [gray]
+    others = all - grays
+    grays .each {|t| assert_equal true,  t.gray?}
+    others.each {|t| assert_equal false, t.gray?}
+  end
+
+  def test_alpha? ()
+    alphas = [alpha]
+    others = all - alphas
+    alphas.each {|t| assert_equal true,  t.alpha?}
+    others.each {|t| assert_equal false, t.alpha?}
+  end
+
+  def test_rgb? ()
+    rgbs   = [rgb, rgba, rgbx, argb, xrgb, rgb_f, rgba_f, argb_f]
+    others = all - rgbs
+    rgbs  .each {|t| assert_equal true,  t.rgb?}
+    others.each {|t| assert_equal false, t.rgb?}
+  end
+
+  def test_bgr? ()
+    bgrs   = [bgr, bgra, bgrx, abgr, xbgr, bgr_f, bgra_f, abgr_f]
+    others = all - bgrs
+    bgrs  .each {|t| assert_equal true,  t.bgr?}
+    others.each {|t| assert_equal false, t.bgr?}
+  end
+
+  def test_float? ()
+    floats = [rgb_f, rgba_f, argb_f, bgr_f, bgra_f, abgr_f]
+    others = all - floats
+    floats.each {|t| assert_equal true,  t.float?}
+    others.each {|t| assert_equal false, t.float?}
+  end
+
+  def test_has_alpha? ()
+    alphas = [alpha, rgba, argb, bgra, abgr, rgba_f, argb_f, bgra_f, abgr_f]
+    others = all - alphas
+    alphas.each {|t| assert_equal true,  t.has_alpha?}
+    others.each {|t| assert_equal false, t.has_alpha?}
+  end
+
+  def test_has_skip? ()
+    skips  = [rgbx, xrgb, bgrx, xbgr]
+    others = all - skips
+    skips.each  {|t| assert_equal true,  t.has_skip?}
+    others.each {|t| assert_equal false, t.has_skip?}
+  end
+
+end# TestColorSpace

data/test/test_font.rb

@@ -25,4 +25,9 @@ class TestFont < Test::Unit::TestCase
     assert_equal w * 2, font.width('XX')
   end
 
+  def test_height ()
+    f = font
+    assert_equal f.height, f.ascent + f.descent + f.leading
+  end
+
 end# TestFont

data/test/test_image.rb

@@ -9,11 +9,11 @@ class TestImage < Test::Unit::TestCase
   W = 10
   H = 10
 
-  def img (w = W, h = H, *args)
+  def image (w = W, h = H, *args)
     Rays::Image.new w, h, *args
   end
 
-  def rgb (r = 0, g = 0, b = 0, a = 0)
+  def color (r = 0, g = 0, b = 0, a = 0)
     Rays::Color.new r, g, b, a
   end
 
@@ -22,25 +22,32 @@ class TestImage < Test::Unit::TestCase
   end
 
   def test_initialize ()
-    assert_equal W, img.width
-    assert_equal H, img.height
+    assert_equal W, image.width
+    assert_equal H, image.height
   end
 
-  def test_bitmap ()
-    assert_equal W, img.bitmap.width
-    assert_equal H, img.bitmap.height
+  def test_dup ()
+    o          = image
+    assert_equal color(0, 0, 0, 0), o[0, 0]
+    o[0, 0]    = color(1, 0, 0, 0)
+    assert_equal color(1, 0, 0, 0), o[0, 0]
+    x          = o.dup
+    assert_equal color(1, 0, 0, 0), x[0, 0]
+    x[0, 0]    = color(0, 1, 0, 0)
+    assert_equal color(0, 1, 0, 0), x[0, 0]
+    assert_equal color(1, 0, 0, 0), o[0, 0]
   end
 
-  def test_texture ()
-    assert_equal W, img.texture.width
-    assert_equal H, img.texture.height
+  def test_bitmap ()
+    assert_equal W, image.bitmap.width
+    assert_equal H, image.bitmap.height
   end
 
   def test_painter ()
-    pa = img.painter
-    assert_equal rgb(0, 0, 0, 0), pa.background
-    assert_equal rgb(1, 1, 1, 1), pa.fill
-    assert_equal rgb(1, 1, 1, 0), pa.stroke
+    pa = image.painter
+    assert_equal color(0, 0, 0, 0), pa.background
+    assert_equal color(1, 1, 1, 1), pa.fill
+    assert_equal color(1, 1, 1, 0), pa.stroke
     assert_equal bounds(0, 0, -1, -1), pa.clip
     assert_equal Rays::Font.new, pa.font
   end
@@ -59,14 +66,11 @@ class TestImage < Test::Unit::TestCase
       fill(&block).bitmap.to_a.reject {|o| o.transparent?}.uniq.size > 0
     end
 
-    assert_equal rgb(0, 0, 0, 0), fill   {|p| p.rect 1, 1, 8, 8}[0, 0]
-    assert_equal rgb(1, 0, 0, 1), fill   {|p| p.rect 1, 1, 8, 8}[1, 1]
-    assert_equal rgb(1, 0, 0, 1), stroke {|p| p.line 0, 0, 1, 1}[0, 0]
+    assert_equal color(0, 0, 0, 0), fill   {|p| p.rect 1, 1, 8, 8}[0, 0]
+    assert_equal color(1, 0, 0, 1), fill   {|p| p.rect 1, 1, 8, 8}[1, 1]
+    assert_equal color(1, 0, 0, 1), stroke {|p| p.line 0, 0, 1, 1}[0, 0]
 
     assert drawn {|p| p.text "a"}
   end
 
-  def test_dirty ()
-  end
-
 end# TestImage

data/test/test_matrix.rb

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestMatrix < Test::Unit::TestCase
+
+  def matrix (*args)
+    Rays::Matrix.new *args
+  end
+
+  def mat_str (str)
+    matrix *str.split(/\s*/).map(&:to_f)
+  end
+
+  def translate (*args)
+    Rays::Matrix.translate *args
+  end
+
+  def scale (*args)
+    Rays::Matrix.scale *args
+  end
+
+  def rotate (*args)
+    Rays::Matrix.rotate *args
+  end
+
+  def point (*args)
+    Rays::Point.new *args
+  end
+
+  def test_initialize ()
+    assert_equal mat_str('1000 0100 0010 0001'), matrix
+    assert_equal mat_str('0000 0000 0000 0000'), matrix(0)
+    assert_equal mat_str('2000 0200 0020 0002'), matrix(2)
+    assert_equal mat_str('1234 5678 9876 5432'), matrix(1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2)
+    (2..15).each do |n|
+      assert_raise(ArgumentError) {matrix *[0] * n}
+    end
+  end
+
+  def test_dup ()
+    o       = matrix
+    assert_equal mat_str('1000 0100 0010 0001'), o
+    o[0, 0] = 9
+    assert_equal mat_str('9000 0100 0010 0001'), o
+    x       = o.dup
+    assert_equal mat_str('9000 0100 0010 0001'), x
+    x[0, 0] = 5
+    assert_equal mat_str('5000 0100 0010 0001'), x
+    assert_equal mat_str('9000 0100 0010 0001'), o
+  end
+
+  def test_mult ()
+    assert_equal point(2, 3), scale(2, 3) * point(1, 1)
+
+    assert_kind_of Rays::Point,  matrix * point
+    assert_kind_of Rays::Point,  matrix * [1]
+    assert_kind_of Rays::Point,  matrix * [1, 2]
+    assert_kind_of Rays::Point,  matrix * [1, 2, 3]
+
+    assert_kind_of Rays::Matrix, matrix * matrix
+    assert_kind_of Rays::Matrix, matrix * ([0] * 16)
+
+    (4..15).each do |narg|
+      assert_raise(ArgumentError) {matrix * ([0] * narg)}
+    end
+  end
+
+  def test_get_at ()
+    o = mat_str '1234 5678 9876 5432'
+    assert_equal 1, o[0, 0]
+    assert_equal 2, o[0, 1]
+  end
+
+  def test_set_at ()
+    o = mat_str '1234 5678 9876 5432'
+    assert_equal 1, o[0, 0]
+    o[0, 0] = 10
+    assert_equal 10, o[0, 0]
+  end
+
+  def test_compare ()
+    o = matrix 1
+    assert     o == mat_str('1000 0100 0010 0001')
+    assert_not o != mat_str('1000 0100 0010 0001')
+
+    assert o < matrix(2)
+    assert o > matrix(0)
+  end
+
+  def test_transform ()
+    assert_equal mat_str('1001 0102 0013 0001'), translate(1, 2, 3)
+    assert_equal mat_str('2000 0300 0040 0001'), scale(2, 3, 4)
+
+    assert_equal point(2, 3, 3), translate(1, 2, 3) * point(1, 1)
+    assert_equal point(2, 2, 0), scale(2, 2)        * point(1, 1)
+
+    assert (rotate(90)          * point(1, 0, 0)).y > 0.99
+    assert (rotate(90, 0, 0, 1) * point(1, 0, 0)).y > 0.99
+    assert (rotate(90, 0, 1, 0) * point(0, 0, 1)).x > 0.99
+    assert (rotate(90, 1, 0, 0) * point(0, 1, 0)).z > 0.99
+  end
+
+end# TestMatrix

data/test/test_painter.rb

@@ -14,50 +14,114 @@ class TestPainter < Test::Unit::TestCase
     Rays::Font.new name, size
   end
 
-  def rgb (*args)
+  def color (*args)
     Rays::Color.new *args
   end
 
+  def setup ()
+    Rays::Color.set_palette_color :rgb001, color(0, 0, 1)
+  end
+
   def test_background_accessor ()
     pa = painter
     pa.background = 1
-    assert_equal rgb(1, 1, 1, 1), pa.background
+    assert_equal   color(1, 1, 1, 1), pa.background
     pa.background = 0
-    assert_equal rgb(0, 0, 0, 1), pa.background
-    pa.background 1
-    assert_equal rgb(1, 1, 1, 1), pa.background
-    assert_equal rgb(1, 1, 1, 1), pa.background(0) {|_|
-      assert_equal rgb(0, 0, 0, 1), pa.background
-    }
-    assert_equal rgb(1, 1, 1, 1), pa.background
+    assert_equal   color(0, 0, 0, 1), pa.background
+    pa.background   1
+    assert_equal   color(1, 1, 1, 1), pa.background
+    pa.push background: 0 do |_|
+      assert_equal color(0, 0, 0, 1), pa.background
+    end
+    assert_equal   color(1, 1, 1, 1), pa.background
   end
 
   def test_fill_accessor ()
     pa = painter
     pa.fill = 1
-    assert_equal rgb(1, 1, 1, 1), pa.fill
+    assert_equal   color(1, 1, 1, 1), pa.fill
     pa.fill = 0
-    assert_equal rgb(0, 0, 0, 1), pa.fill
-    pa.fill 1
-    assert_equal rgb(1, 1, 1, 1), pa.fill
-    assert_equal rgb(1, 1, 1, 1), pa.fill(0) {|_|
-      assert_equal rgb(0, 0, 0, 1), pa.fill
-    }
-    assert_equal rgb(1, 1, 1, 1), pa.fill
+    assert_equal   color(0, 0, 0, 1), pa.fill
+    pa.fill   1
+    assert_equal   color(1, 1, 1, 1), pa.fill
+    pa.push fill: 0 do |_|
+      assert_equal color(0, 0, 0, 1), pa.fill
+    end
+    assert_equal   color(1, 1, 1, 1), pa.fill
   end
 
   def test_stroke_accessor ()
     pa = painter
     pa.stroke = 1
-    assert_equal rgb(1, 1, 1, 1), pa.stroke
+    assert_equal   color(1, 1, 1, 1), pa.stroke
     pa.stroke = 0
-    assert_equal rgb(0, 0, 0, 1), pa.stroke
-    pa.stroke 1
-    assert_equal rgb(1, 1, 1, 1), pa.stroke
-    assert_equal rgb(1, 1, 1, 1), pa.stroke(0) {|_|
-      assert_equal rgb(0, 0, 0, 1), pa.stroke
-    }
-    assert_equal rgb(1, 1, 1, 1), pa.stroke
+    assert_equal   color(0, 0, 0, 1), pa.stroke
+    pa.stroke   1
+    assert_equal   color(1, 1, 1, 1), pa.stroke
+    pa.push stroke: 0 do |_|
+      assert_equal color(0, 0, 0, 1), pa.stroke
+    end
+    assert_equal   color(1, 1, 1, 1), pa.stroke
+  end
+
+  def test_stroke_width_accessor ()
+    pa = painter
+    assert_equal          0, pa.stroke_width
+    pa.stroke_width =     1
+    assert_equal          1, pa.stroke_width
+    pa.stroke_width =     0
+    assert_equal          0, pa.stroke_width
+    pa.stroke_width       2
+    assert_equal          2, pa.stroke_width
+    pa.push stroke_width: 3 do |_|
+      assert_equal        3, pa.stroke_width
+    end
+    assert_equal          2, pa.stroke_width
+  end
+
+  def test_stroke_cap_accessor ()
+    pa = painter
+    assert_equal        :butt,   pa.stroke_cap
+    pa.stroke_cap =     :round
+    assert_equal        :round,  pa.stroke_cap
+    pa.stroke_cap       :square
+    assert_equal        :square, pa.stroke_cap
+    pa.push stroke_cap: :butt do |_|
+      assert_equal      :butt,   pa.stroke_cap
+    end
+    assert_equal        :square, pa.stroke_cap
+    assert_raise(ArgumentError) {pa.stroke_cap :foo}
+    assert_raise(ArgumentError) {pa.stroke_cap :BUTT}
+    assert_raise(ArgumentError) {pa.stroke_cap Rays::CAP_BUTT}# ToDo: accept this
+  end
+
+  def test_stroke_join_accessor ()
+    pa = painter
+    assert_equal         :miter,  pa.stroke_join
+    pa.stroke_join =     :round
+    assert_equal         :round,  pa.stroke_join
+    pa.stroke_join       :square
+    assert_equal         :square, pa.stroke_join
+    pa.push stroke_join: :miter do |_|
+      assert_equal       :miter,  pa.stroke_join
+    end
+    assert_equal         :square, pa.stroke_join
+    assert_raise(ArgumentError) {pa.stroke_join :foo}
+    assert_raise(ArgumentError) {pa.stroke_join :MITER}
+    assert_raise(ArgumentError) {pa.stroke_join Rays::JOIN_MITER}# ToDo: accept this
+  end
+
+  def test_miter_limit_accessor ()
+    pa = painter
+    assert_equal         2, pa.miter_limit
+    pa.miter_limit =     3
+    assert_equal         3, pa.miter_limit
+    pa.miter_limit       4
+    assert_equal         4, pa.miter_limit
+    pa.push miter_limit: 9 do |_|
+      assert_equal       9, pa.miter_limit
+    end
+    assert_equal         4, pa.miter_limit
   end
 
   def test_clip_accessor ()
@@ -66,11 +130,11 @@ class TestPainter < Test::Unit::TestCase
     assert_equal [1, 2, 3, 4], pa.clip.to_a
     pa.clip = [5, 6, 7, 8]
     assert_equal [5, 6, 7, 8], pa.clip.to_a
-    pa.clip 1, 2, 3, 4
+    pa.clip    1, 2, 3, 4
     assert_equal [1, 2, 3, 4], pa.clip.to_a
-    assert_equal [1, 2, 3, 4], pa.clip(5, 6, 7, 8) {|_|
+    pa.push clip: [5, 6, 7, 8] do |_|
       assert_equal [5, 6, 7, 8], pa.clip.to_a
-    }.to_a
+    end
     assert_equal [1, 2, 3, 4], pa.clip.to_a
   end
 
@@ -81,11 +145,11 @@ class TestPainter < Test::Unit::TestCase
     assert_equal f10, pa.font
     pa.font = f20
     assert_equal f20, pa.font
-    pa.font f10
+    pa.font   f10
     assert_equal f10, pa.font
-    assert_equal f10, pa.font(f20) {|_|
+    pa.push font: f20 do |_|
       assert_equal f20, pa.font
-    }
+    end
     assert_equal f10, pa.font
   end
 
@@ -100,30 +164,72 @@ class TestPainter < Test::Unit::TestCase
     assert_equal 20, pa.font.size
   end
 
-  def test_color_accessor ()
+  def test_color_by_name ()
     pa = painter
-    f1, f2, s1, s2 = rgb(1, 0, 0), rgb(0, 1, 0), rgb(1, 0, 1), rgb(0, 1, 1)
-    pa.color f1, s1
-    assert_equal f1, pa.fill
-    assert_equal s1, pa.stroke
-    assert_equal [f1, s1], pa.color(f2, s2) {|_|
-      assert_equal f2, pa.fill
-      assert_equal s2, pa.stroke
-    }
-    assert_equal f1, pa.fill
-    assert_equal s1, pa.stroke
+    pa.fill =         :rgb001
+    assert_equal color(0, 0, 1), pa.fill
+    pa.fill =         [1, 0, 0]
+    assert_equal color(1, 0, 0), pa.fill
+    pa.fill            0, 1, 0
+    assert_equal color(0, 1, 0), pa.fill
+    pa.fill =         '#f00'
+    assert_equal color(1, 0, 0), pa.fill
+    pa.fill           '#0f0'
+    assert_equal color(0, 1, 0), pa.fill
+    pa.fill =         '#ff0000'
+    assert_equal color(1, 0, 0), pa.fill
+    pa.fill           '#00ff00'
+    assert_equal color(0, 1, 0), pa.fill
   end
 
-  def test_color_by_name ()
+  def test_push ()
     pa = painter
-    pa.fill = [1, 0, 0]
-    assert_equal rgb(1, 0, 0), pa.fill
-    pa.fill = :red
-    assert_equal rgb(1, 0, 0), pa.fill
-    pa.fill = '#f00'
-    assert_equal rgb(1, 0, 0), pa.fill
-    pa.fill = '#ff0000'
-    assert_equal rgb(1, 0, 0), pa.fill
+    pa.fill =           [1, 0, 0]
+    assert_equal   color(1, 0, 0), pa.fill
+
+    pa.push :all do |_|
+      assert_equal color(1, 0, 0), pa.fill
+      pa.fill =         [0, 1, 0]
+      assert_equal color(0, 1, 0), pa.fill
+    end
+    assert_equal   color(1, 0, 0), pa.fill
+
+    pa.push :state do |_|
+      assert_equal color(1, 0, 0), pa.fill
+      pa.fill =         [0, 1, 0]
+      assert_equal color(0, 1, 0), pa.fill
+    end
+    assert_equal   color(1, 0, 0), pa.fill
+
+    pa.push :matrix do |_|
+      assert_equal color(1, 0, 0), pa.fill
+      pa.fill =         [0, 1, 0]
+      assert_equal color(0, 1, 0), pa.fill
+    end
+    assert_equal   color(0, 1, 0), pa.fill
+
+    pa.push fill:       [0, 0, 1] do |_|
+      assert_equal color(0, 0, 1), pa.fill
+      pa.fill =         [1, 0, 0]
+      assert_equal color(1, 0, 0), pa.fill
+    end
+    assert_equal   color(0, 1, 0), pa.fill
+
+    pa.push stroke:     [0, 0, 1] do |_|
+      assert_equal color(0, 1, 0), pa.fill
+      pa.fill =         [1, 0, 0]
+      assert_equal color(1, 0, 0), pa.fill
+    end
+    assert_equal   color(0, 1, 0), pa.fill
+  end
+
+  def test_shader ()
+    img = Rays::Image.new(10, 10).paint {
+      shader "void main() {gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);}"
+      fill   1, 0, 0
+      rect   bounds
+    }
+    assert_equal [0.0, 0.0, 1.0, 1.0], img[0, 0].to_a
   end
 
 end# TestPainter