processing 0.5.31 → 0.5.33

data/test/test_graphics_context.rb

@@ -8,7 +8,7 @@ class TestGraphicsContext < Test::Unit::TestCase
 
   THRESHOLD_TO_BE_FIXED = 0.0
 
-  def test_color()
+  def test_rgb_color()
     g = graphics
 
     g.colorMode G::RGB, 255
@@ -23,6 +23,32 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_in_delta 0.2, g.green(c), 1 / 256.0
     assert_in_delta 0.3, g.blue(c),  1 / 256.0
     assert_in_delta 0.4, g.alpha(c), 1 / 256.0
+
+    g.colorMode G::RGB, 0.5
+    c = g.color 0.1, 0.2, 0.3, 0.4
+    assert_equal 0xcc336699, c
+    assert_in_delta 0.1, g.red(c),   1 / 256.0
+    assert_in_delta 0.2, g.green(c), 1 / 256.0
+    assert_in_delta 0.3, g.blue(c),  1 / 256.0
+    assert_in_delta 0.4, g.alpha(c), 1 / 256.0
+  end
+
+  def test_hsb_color()
+    g = graphics
+
+    g.colorMode G::HSB, 1.0
+    c = g.color 0.1, 0.2, 0.3, 0.4
+    assert_in_delta 0.1, g.hue(c),        1 / 256.0
+    assert_in_delta 0.2, g.saturation(c), 1 / 256.0
+    assert_in_delta 0.3, g.brightness(c), 1 / 256.0
+    assert_in_delta 0.4, g.alpha(c),      1 / 256.0
+
+    g.colorMode G::HSB, 0.5
+    c = g.color 0.1, 0.2, 0.3, 0.4
+    assert_in_delta 0.1, g.hue(c),        1 / 256.0
+    assert_in_delta 0.2, g.saturation(c), 1 / 256.0
+    assert_in_delta 0.3, g.brightness(c), 1 / 256.0
+    assert_in_delta 0.4, g.alpha(c),      1 / 256.0
   end
 
   def test_colorMode()
@@ -76,6 +102,85 @@ class TestGraphicsContext < Test::Unit::TestCase
     END
   end
 
+  def test_textFont()
+    graphics do |g|
+      arial10     = g.createFont 'Arial',     10
+      helvetica11 = g.createFont 'Helvetica', 11
+
+      font        = -> {g.instance_variable_get(:@textFont__).getInternal__}
+      painterFont = -> {g.instance_variable_get(:@painter__).font}
+
+      assert_not_nil            font[]       .name
+      assert_not_equal 'Arial', font[]       .name
+      assert_equal     12,      font[]       .size
+      assert_equal     12,      painterFont[].size
+
+      g.textFont arial10
+      assert_equal 'Arial', font[]       .name
+      assert_equal 10,      font[]       .size
+      assert_equal 10,      painterFont[].size
+
+      g.push do
+        g.textFont helvetica11
+        assert_equal 'Helvetica', font[]       .name
+        assert_equal 11,          font[]       .size
+        assert_equal 11,          painterFont[].size
+      end
+
+      assert_equal 'Arial', font[]       .name
+      assert_equal 10,      font[]       .size
+      assert_equal 10,      painterFont[].size
+
+      g.push do
+        g.textFont arial10, 13
+        assert_equal 'Arial', font[]       .name
+        assert_equal 13,      font[]       .size
+        assert_equal 13,      painterFont[].size
+      end
+
+      assert_equal 'Arial', font[]       .name
+      assert_equal 10,      font[]       .size
+      assert_equal 10,      painterFont[].size
+    end
+  end
+
+  def test_textSize()
+    graphics do |g|
+      font        = -> {g.instance_variable_get(:@textFont__).getInternal__}
+      painterFont = -> {g.instance_variable_get(:@painter__).font}
+
+      assert_equal 12, font[]       .size
+      assert_equal 12, painterFont[].size
+
+      g.push do
+        g.textSize 10
+        assert_equal 10, font[]       .size
+        assert_equal 10, painterFont[].size
+      end
+
+      assert_equal 12, font[]       .size
+      assert_equal 12, painterFont[].size
+    end
+  end
+
+  def test_textLeading()
+    assert_p5_draw <<~END, threshold: 0.97
+      noStroke
+      textSize 200
+      push
+      text "X\nX", 100, 200
+      textLeading 300
+      text "X\nX", 250, 200
+      textLeading 400
+      text "X\nX", 400, 200
+      textLeading 100
+      text "X\nX", 550, 200
+      textLeading 0
+      text "X\nX", 700, 200
+      pop
+    END
+  end
+
   def test_clear()
     colors = -> g {get_pixels(g).uniq}
 
@@ -186,16 +291,42 @@ class TestGraphicsContext < Test::Unit::TestCase
 
   def test_curve()
     src = 'curve 100,100, 100,500, 500,500, 600,100'
-    assert_p5_fill        src, threshold: 0
-    assert_p5_stroke      src, threshold: 0
-    assert_p5_fill_stroke src, threshold: 0
+    assert_p5_fill        src, threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
   end
 
   def test_bezier()
-    src = 'curve 100,100, 100,500, 500,500, 600,100'
-    assert_p5_fill        src, threshold: 0
-    assert_p5_stroke      src, threshold: 0
-    assert_p5_fill_stroke src, threshold: 0
+    src = 'bezier 100,100, 100,500, 500,500, 600,100'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_curveDetail()
+    opts = {
+      webgl: true,
+      # tests in headless mode will time out...
+      headless: false,
+      # Something is wrong with the behavior of `p5.js + WEBGL + curve()`
+      threshold: THRESHOLD_TO_BE_FIXED
+    }
+    [1, 2, 3, 5, 10, 100].each do |detail|
+      assert_p5_stroke <<~END, label: test_label(2, suffix: detail), **opts
+        curveDetail #{detail}
+        curve 100,100, 100,500, 500,500, 600,100
+       END
+    end
+  end
+
+  def test_bezierDetail()
+    opts = {webgl: true, headless: false} # tests in headless mode will time out...
+    [1, 2, 3, 5, 10, 100].each do |detail|
+      assert_p5_stroke <<~END, label: test_label(2, suffix: detail), **opts
+        bezierDetail #{detail}
+        bezier 100,100, 100,500, 500,500, 600,100
+      END
+    end
   end
 
   def test_shape_with_shapeMode_corner()
@@ -468,6 +599,330 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_p5_fill_stroke src, 'endShape CLOSE'
   end
 
+  def test_beginShape_with_fill()
+    assert_equal_draw <<~HEADER, <<~EXPECTED, <<~ACTUAL
+      noStroke
+    HEADER
+      fill 0, 255, 0
+      rect 100, 100, 500, 400
+    EXPECTED
+      beginShape
+      fill 0, 255, 0
+      vertex 100, 100
+      vertex 600, 100
+      vertex 600, 500
+      vertex 100, 500
+      endShape
+    ACTUAL
+  end
+
+  def test_curveVertex()
+    src = <<~END
+      beginShape
+      curveVertex 100, 100
+      curveVertex 800, 100
+      curveVertex 800, 800
+      curveVertex 100, 800
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+
+    src = <<~END
+      beginShape
+      curveVertex 200, 200
+      curveVertex 200, 200
+      curveVertex 800, 200
+      curveVertex 800, 400
+      curveVertex 200, 400
+      curveVertex 200, 800
+      curveVertex 800, 800
+      curveVertex 800, 700
+      curveVertex 800, 700
+    END
+    assert_p5_fill        src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_bezierVertex()
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      bezierVertex 900, 100, 900, 900, 200, 500
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      bezierVertex 900, 100, 900, 500, 300, 500
+      bezierVertex 100, 900, 900, 900, 900, 600
+    END
+    assert_p5_fill        src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_quadraticVertex()
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      quadraticVertex 800, 500, 200, 800
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      quadraticVertex 800, 100, 500, 500
+      quadraticVertex 100, 800, 800, 800
+    END
+    assert_p5_fill        src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_contour()
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      vertex 100, 900
+      vertex 900, 900
+      vertex 900, 100
+      beginContour
+      vertex 200, 200
+      vertex 800, 200
+      vertex 700, 700
+      vertex 200, 800
+      endContour
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+  end
+
+  def test_pixels()
+    g = graphics 2, 2
+
+    g.loadPixels
+    assert_equal [0] * 4, g.pixels
+    assert_equal [0] * 4, g.getInternal__.pixels
+
+    g.pixels.replace [0xffff0000, 0xff00ff00, 0xff0000ff, 0xff000000]
+    assert_equal [0xffff0000, 0xff00ff00, 0xff0000ff, 0xff000000], g.pixels
+    assert_equal [0] * 4,                                          g.getInternal__.pixels
+
+    g.updatePixels
+    assert_nil                                                     g.pixels
+    assert_equal [0xffff0000, 0xff00ff00, 0xff0000ff, 0xff000000], g.getInternal__.pixels
+    assert_nothing_raised {g.updatePixels}
+
+    g.loadPixels
+    g.pixels.replace [0xff000000]
+    assert_raise(ArgumentError) {g.updatePixels}
+  end
+
+  def test_pixels_and_modified_flags()
+    drawRect     = -> g, x, *rgb do
+      g.beginDraw do
+        g.fill(*rgb)
+        g.rect x, 0, 2, 2
+      end
+    end
+    updatePixels = -> g, i, *rgb do
+      g.loadPixels
+      g.pixels[i] = g.color(*rgb)
+      g.updatePixels
+    end
+    getPixels    = -> g do
+      g.getInternal__.pixels
+        .select.with_index {|_, i| i.even?}
+        .map {|n| n.to_s 16}
+    end
+
+    g = graphics 6, 1
+    drawRect    .call g, 0, 255,0,0
+    assert_equal %w[ffff0000 0        0],        getPixels.call(g)
+
+    g = graphics 6, 1
+    drawRect    .call g, 0, 255,0,0
+    updatePixels.call g, 2, 0,255,0
+    assert_equal %w[ffff0000 ff00ff00 0],        getPixels.call(g)
+
+    g = graphics 6, 1
+    drawRect    .call g, 0, 255,0,0
+    updatePixels.call g, 2, 0,255,0
+    drawRect    .call g, 4, 0,0,255
+    assert_equal %w[ffff0000 ff00ff00 ff0000ff], getPixels.call(g)
+  end
+
+  def test_rotateX()
+    assert_p5_draw <<~END, webgl: true, headless: false
+      noStroke
+      translate 100, 100
+      rotateX PI * 0.1
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_rotateY()
+    assert_p5_draw <<~END, webgl: true, headless: false
+      noStroke
+      translate 100, 100
+      rotateY PI * 0.1
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_rotateZ()
+    assert_p5_draw <<~END, webgl: true, headless: false
+      noStroke
+      translate 100, 100
+      rotateZ PI * 0.1
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_shearX()
+    assert_p5_draw <<~END
+      translate 100, 100
+      shearX PI * 0.2
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_shearY()
+    assert_p5_draw <<~END
+      translate 100, 100
+      shearY PI * 0.2
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_applyMatrix()
+    g = graphics
+
+    painterMatrix = -> {g.instance_variable_get(:@painter__).matrix.to_a}
+
+    g.beginDraw do
+      g.resetMatrix
+      g.applyMatrix  1,2,     3,4,              5,6
+      assert_equal  [1,2,0,0, 3,4,0,0, 0,0,1,0, 5,6,0,1], painterMatrix.call
+
+      g.resetMatrix
+      g.applyMatrix [1,2,     3,4,              5,6]
+      assert_equal  [1,2,0,0, 3,4,0,0, 0,0,1,0, 5,6,0,1], painterMatrix.call
+
+      g.resetMatrix
+      g.applyMatrix  1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16
+      assert_equal  [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16], painterMatrix.call
+
+      g.resetMatrix
+      g.applyMatrix [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16]
+      assert_equal  [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16], painterMatrix.call
+
+      ((0..17).to_a - [6, 16]).each do |n|
+        assert_raise(ArgumentError) {g.applyMatrix   [0] * n}
+        assert_raise(ArgumentError) {g.applyMatrix(*([0] * n))}
+      end
+    end
+  end
+
+  def test_applyMatrix_translate()
+    assert_p5_draw <<~END
+      applyMatrix  1, 0, 0, 1, 100, 200
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw <<~END
+      applyMatrix [1, 0, 0, 1, 100, 200]
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false
+      applyMatrix  1,0,0,0, 0,1,0,0, 0,0,1,0, 100,200,0,1
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false
+      applyMatrix [1,0,0,0, 0,1,0,0, 0,0,1,0, 100,200,0,1]
+      rect 100, 100, 500, 600
+    END
+  end
+
+  def test_applyMatrix_scale()
+    assert_p5_draw <<~END
+      applyMatrix  2, 0, 0, 3, 0, 0
+      rect 100, 100, 200, 200
+    END
+    assert_p5_draw <<~END
+      applyMatrix [2, 0, 0, 3, 0, 0]
+      rect 100, 100, 200, 200
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false, threshold: THRESHOLD_TO_BE_FIXED
+      applyMatrix  2,0,0,0, 0,3,0,0, 0,0,1,0, 0,0,0,1
+      rect 100, 100, 200, 200
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false, threshold: THRESHOLD_TO_BE_FIXED
+      applyMatrix [2,0,0,0, 0,3,0,0, 0,0,1,0, 0,0,0,1]
+      rect 100, 100, 200, 200
+    END
+  end
+
+  def test_applyMatrix_rotate()
+    header = 's, c = Math.sin(Math::PI / 10), Math.cos(Math::PI / 10)'
+    assert_p5_draw header, <<~END
+      applyMatrix  c, s, -s, c, 0, 0
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw header, <<~END
+      applyMatrix [c, s, -s, c, 0, 0]
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw header, <<~END, webgl: true, headless: false
+      applyMatrix  c,s,0,0, -s,c,0,0, 0,0,1,0, 0,0,0,1
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw header, <<~END, webgl: true, headless: false
+      applyMatrix [c,s,0,0, -s,c,0,0, 0,0,1,0, 0,0,0,1]
+      rect 100, 100, 500, 600
+    END
+  end
+
+  def test_applyMatrix_multiple_times()
+    assert_p5_draw <<~END
+      applyMatrix 1, 0, 0, 1, 100, 200
+      s = Math.sin(Math::PI / 10)
+      c = Math.cos(Math::PI / 10)
+      applyMatrix c, s, -s, c, 0, 0
+      applyMatrix 2, 0, 0, 3, 0, 0
+      rect 100, 100, 100, 100
+    END
+  end
+
   def test_lerp()
     g = graphics
 
@@ -491,6 +946,16 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_equal c[ 70, 80, 90], g.lerpColor(c[10, 20, 30], c[50, 60, 70],  1.5)
   end
 
+  def test_createFont()
+    g = graphics
+
+    assert_not_nil        g.createFont(nil,     nil).getInternal__.name
+    assert_equal 'Arial', g.createFont('Arial', nil).getInternal__.name
+
+    assert_equal 12, g.createFont(nil, nil).getInternal__.size
+    assert_equal 10, g.createFont(nil, 10) .getInternal__.size
+  end
+
   def test_createShape_line()
     assert_equal_draw <<~EXPECTED, <<~ACTUAL
       line 100, 200, 800, 900
@@ -539,4 +1004,193 @@ class TestGraphicsContext < Test::Unit::TestCase
     ACTUAL
   end
 
+  def test_curvePoint()
+    assert_p5_draw <<~END
+      steps = 8
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f;
+        x = curvePoint(*[20,  20,  292, 292].map {|n| n * 3}, t)
+        y = curvePoint(*[104, 104, 96,  244].map {|n| n * 3}, t)
+        point x, y
+        x = curvePoint(*[20,  292, 292, 60] .map {|n| n * 3}, t)
+        y = curvePoint(*[104, 96,  244, 260].map {|n| n * 3}, t)
+        point x, y
+      end
+    END
+  end
+
+  def test_bezierPoint()
+    assert_p5_draw <<~END
+      steps = 10
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f
+        x = bezierPoint(*[85, 10, 90, 15].map {|n| n * 10}, t)
+        y = bezierPoint(*[20, 10, 90, 80].map {|n| n * 10}, t)
+        point x, y
+      end
+    END
+  end
+
+  def test_curveTangent()
+    assert_p5_draw <<~END
+      drawTangent = -> x, y, tx, ty do
+        tv = createVector tx, ty
+        tv.normalize
+        tv.rotate radians(-90)
+        point x, y
+        push
+        stroke 0, 0, 255
+        strokeWeight 20
+        line x, y, x + tv.x * 100, y + tv.y * 100
+        pop
+      end
+      steps = 8
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f;
+
+        xx = [20,  20,  292, 292].map {|n| n * 2}
+        yy = [104, 104, 96,  244].map {|n| n * 3}
+        x  = curvePoint(  *xx, t)
+        y  = curvePoint(  *yy, t)
+        tx = curveTangent(*xx, t)
+        ty = curveTangent(*yy, t)
+        drawTangent.call x, y, tx, ty
+
+        xx = [20,  292, 292, 60] .map {|n| n * 2}
+        yy = [104, 96,  244, 260].map {|n| n * 3}
+        x  = curvePoint(  *xx, t)
+        y  = curvePoint(  *yy, t)
+        tx = curveTangent(*xx, t)
+        ty = curveTangent(*yy, t)
+        drawTangent.call x, y, tx, ty
+      end
+    END
+  end
+
+  def test_bezierTangent()
+    assert_p5_draw <<~END
+      drawTangent = -> x, y, tx, ty do
+        tv = createVector tx, ty
+        tv.normalize
+        tv.rotate radians(-90)
+        point x, y
+        push
+        stroke 0, 0, 255
+        strokeWeight 20
+        line x, y, x + tv.x * 100, y + tv.y * 100
+        pop
+      end
+      steps = 10
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f
+
+        xx = *[85, 10, 90, 15].map {|n| n * 10}
+        yy = *[20, 10, 90, 80].map {|n| n * 10}
+        x  = bezierPoint(  *xx, t)
+        y  = bezierPoint(  *yy, t)
+        tx = bezierTangent(*xx, t)
+        ty = bezierTangent(*yy, t)
+        drawTangent.call x, y, tx, ty
+      end
+    END
+  end
+
+  def test_random()
+    g = graphics
+
+    assert_equal Float, g.random()        .class
+    assert_equal Float, g.random(1)       .class
+    assert_equal Float, g.random(1.0)     .class
+    assert_equal Float, g.random(1,   2)  .class
+    assert_equal Float, g.random(1.0, 2.0).class
+
+    assert_not_equal g.random(1.0), g.random(1.0)
+
+    assert_raise(ArgumentError) {g.random 0}
+    assert_raise(ArgumentError) {g.random 1, 1}
+
+    array = 10000.times.map {g.random 1, 2}
+    assert array.all? {|n| (1.0...2.0).include? n}
+    assert_in_delta 1.5, array.sum.to_f / array.size, 0.01
+  end
+
+  def test_random_choice()
+    g = graphics
+
+    assert_equal :a,  g.random([:a])
+    assert_equal :a,  g.random([:a, :a])
+    assert_equal nil, g.random([])
+    assert_equal nil, g.random([nil])
+
+    array = 10000.times.map {g.random([1, 2])}
+    assert array.all? {|n| (1..10).include? n}
+    assert_in_delta 1.5, array.sum.to_f / array.size, 0.02
+  end
+
+  def test_randomSeed()
+    g = graphics
+                    r0 = g.random 1
+    g.randomSeed 1; r1 = g.random 1
+    g.randomSeed 2; r2 = g.random 1
+
+    assert_equal 3, [r0, r1, r2].uniq.size
+
+    g.randomSeed 1
+    assert_equal r1, g.random(1)
+  end
+
+  def test_randomSeed_choice()
+    g = graphics
+                    r0 = g.random((0...10000).to_a)
+    g.randomSeed 1; r1 = g.random((0...10000).to_a)
+    g.randomSeed 2; r2 = g.random((0...10000).to_a)
+
+    assert_equal 3, [r0, r1, r2].uniq.size
+
+    g.randomSeed 1
+    assert_equal r1, g.random((0...10000).to_a)
+  end
+
+  def test_randomGaussian()
+    g = graphics
+
+    assert_equal Float, g.randomGaussian.class
+
+    array = 10000.times.map {g.randomGaussian}
+    assert array.select {|n| (0...3).include? n.abs}.size > 9800
+    assert_in_delta 0, array.sum.to_f / array.size, 0.05
+  end
+
+  def test_noise()
+    g = graphics
+    assert_equal     g.noise(0.1, 0.2, 0.3), g.noise(0.1, 0.2, 0.3)
+    assert_not_equal g.noise(0.1, 0.2, 0.3), g.noise(0.2, 0.2, 0.3)
+    assert_not_equal g.noise(0.1, 0.2, 0.3), g.noise(0.1, 0.3, 0.3)
+    assert_not_equal g.noise(0.1, 0.2, 0.3), g.noise(0.1, 0.2, 0.4)
+  end
+
+  def test_noiseSeed()
+    g = graphics
+                   n0 = g.noise 0.1, 0.2, 0.3
+    g.noiseSeed 1; n1 = g.noise 0.1, 0.2, 0.3
+    g.noiseSeed 2; n2 = g.noise 0.1, 0.2, 0.3
+
+    assert_equal 3, [n0, n1, n2].uniq.size
+
+    g.noiseSeed 1
+    assert_equal n1, g.noise(0.1, 0.2, 0.3)
+  end
+
+  def test_noiseDetail()
+    g = graphics
+                     n0 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 1; n1 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 2; n2 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 3; n3 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 4; n4 = g.noise 0.1, 0.2, 0.3
+
+    assert_equal 4,  [n1, n2, n3, n4].uniq.size
+    assert_equal n4, n0
+  end
+
 end# TestGraphicsContext