processing 0.5.30 → 0.5.31

data/test/helper.rb

@@ -5,28 +5,62 @@
 require 'xot/test'
 require 'processing/all'
 
+require 'digest/md5'
+require 'fileutils'
 require 'tempfile'
 require 'test/unit'
 
 include Xot::Test
 
 
-def temppath(ext: nil, &block)
+DEFAULT_DRAW_HEADER = <<~END
+  background 100
+  fill 255, 0, 0
+  stroke 0, 255, 0
+  strokeWeight 50
+END
+
+
+def test_with_p5?()
+  ENV['TEST_WITH_P5'] == '1'
+end
+
+def md5(s)
+  Digest::MD5.hexdigest s
+end
+
+def mkdir(dir: nil, filename: nil)
+  path = dir || File.dirname(filename)
+  FileUtils.mkdir_p path unless File.exist? path
+end
+
+def test_label(index = 1)
+  caller_locations[index].then {|loc| "#{loc.label}_#{loc.lineno}"}
+end
+
+def temp_path(ext: nil, &block)
   f     = Tempfile.new
   path  = f.path
-  path += ".#{ext}" if ext
+  path += ext if ext
   f.close!
   block.call path
   File.delete path
 end
 
+def draw_output_path(label, *sources, ext: '.png', dir: ext)
+  src  = sources.compact.then {|ary| ary.empty? ? '' : "_#{md5 ary.join("\n")}"}
+  path = File.join __dir__, dir, label + src + ext
+  mkdir filename: path
+  path
+end
+
 def get_pixels(image)
   %i[@image @image__]
     .map {image.instance_variable_get _1}
     .compact
     .first
     .bitmap
-    .to_a
+    .pixels
 end
 
 def graphics(width = 10, height = 10, *args, &block)
@@ -35,6 +69,14 @@ def graphics(width = 10, height = 10, *args, &block)
   end
 end
 
+def test_draw(*sources, width: 1000, height: 1000, pixelDensity: 1, label: nil)
+  graphics(width, height, pixelDensity).tap do |g|
+    g.beginDraw {g.instance_eval sources.compact.join("\n")}
+    g.save draw_output_path(label, *sources) if label
+  end
+end
+
+
 def assert_equal_vector(v1, v2, delta = 0.000001)
   assert_in_delta v1.x, v2.x, delta
   assert_in_delta v1.y, v2.y, delta
@@ -52,3 +94,44 @@ def assert_equal_pixels(expected, actual, threshold: 1.0)
     The rate of the same pixel #{equal_rate} is below the threshold #{threshold}
   EOS
 end
+
+def assert_equal_draw(
+  *shared_header, expected, actual, default_header: DEFAULT_DRAW_HEADER,
+  width: 1000, height: 1000, threshold: 1.0, label: test_label)
+
+  e = test_draw default_header, *shared_header, expected, label: "#{label}_expected"
+  a = test_draw default_header, *shared_header, actual,   label: "#{label}_actual"
+
+  assert_equal_pixels e, a, threshold: threshold
+end
+
+def assert_p5_draw(
+  *sources, default_header: DEFAULT_DRAW_HEADER,
+  width: 1000, height: 1000, threshold: 0.99, label: test_label)
+
+  return unless test_with_p5?
+
+  source = [default_header, *sources].compact.join("\n")
+  path   = draw_output_path "#{label}_expected", source
+
+  pd     = draw_p5rb width, height, source, path, headless: true
+  actual = test_draw source, width: width, height: height, pixelDensity: pd
+  actual.save path.sub('_expected', '_actual')
+
+  assert_equal_pixels actual.loadImage(path), actual, threshold: threshold
+end
+
+def assert_p5_fill(*sources, **kwargs)
+  assert_p5_draw 'noStroke', *sources, label: test_label, **kwargs
+end
+
+def assert_p5_stroke(*sources, **kwargs)
+  assert_p5_draw 'noFill; stroke 0, 255, 0', *sources, label: test_label, **kwargs
+end
+
+def assert_p5_fill_stroke(*sources, **kwargs)
+  assert_p5_draw 'stroke 0, 255, 0', *sources, label: test_label, **kwargs
+end
+
+
+require_relative 'p5' if test_with_p5?

data/test/{draw/p5.rb → p5.rb}

@@ -37,9 +37,6 @@ def get_p5rb_html(width, height, draw_src)
             createCanvas #{width}, #{height}
           end
           def draw()
-            background 0
-            fill 255, 0, 0
-            noStroke
             #{draw_src}
             JS.global.completed
           end
@@ -51,12 +48,28 @@ def get_p5rb_html(width, height, draw_src)
   END
 end
 
+def sleep_until (try: 3, timeout: 10, &block)
+  now = -> offset = 0 {Time.now.to_f + offset}
+  limit = now[timeout]
+  until block.call
+    if now[] > limit
+      limit = now[timeout]
+      try -= 1
+      next if try > 0
+      raise 'Drawing timed out in p5.rb'
+    end
+    sleep 0.1
+  end
+end
+
 def draw_p5rb(width, height, draw_src, path, headless: true)
   b = browser width, height, headless: headless
   unless File.exist? path
     b.reset
     b.main_frame.content = get_p5rb_html width, height, draw_src
-    sleep 0.1 until b.evaluate 'document.querySelector("#completed") != null'
+    sleep_until do
+      b.evaluate 'document.querySelector("#completed") != null'
+    end
     b.screenshot path: path
   end
   b.device_pixel_ratio

data/test/test_graphics.rb

@@ -3,12 +3,6 @@ require_relative 'helper'
 
 class TestGraphics < Test::Unit::TestCase
 
-  P = Processing
-
-  def graphics(w = 10, h = 10)
-    P::Graphics.new w, h
-  end
-
   def test_beginDraw()
     g = graphics
     g.beginDraw
@@ -24,7 +18,7 @@ class TestGraphics < Test::Unit::TestCase
       g.ellipseMode :corner
       g.ellipse 0, 0, g.width, g.height
     end
-    temppath(ext: 'png') do |path|
+    temp_path(ext: '.png') do |path|
       assert_nothing_raised {g.save path}
       assert_equal_pixels g, g.loadImage(path)
     end

data/test/test_graphics_context.rb

@@ -6,9 +6,7 @@ class TestGraphicsContext < Test::Unit::TestCase
   P = Processing
   G = P::Graphics
 
-  def graphics(w = 10, h = 10)
-    G.new w, h
-  end
+  THRESHOLD_TO_BE_FIXED = 0.0
 
   def test_color()
     g = graphics
@@ -57,8 +55,29 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_raise {g.blendMode LEFT}
   end
 
+  def test_default_background_color()
+    assert_p5_draw '', default_header: '', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_default_fill_color()
+    assert_p5_draw <<~END, default_header: nil
+      background 100
+      noStroke
+      rect 100, 100, 500, 500
+    END
+  end
+
+  def test_default_stroke_color()
+    assert_p5_draw <<~END, default_header: nil
+      background 100
+      noFill
+      strokeWeight 50
+      line 100, 100, 500, 500
+    END
+  end
+
   def test_clear()
-    colors = -> g {get_pixels(g).map(&:to_a).flatten.uniq}
+    colors = -> g {get_pixels(g).uniq}
 
     g = graphics
     assert_equal     [0], colors[g]
@@ -70,6 +89,385 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_equal     [0], colors[g]
   end
 
+  def test_point()
+    src = 'strokeWeight 300; point 500, 600'
+    assert_p5_fill        src
+    assert_p5_stroke      src, threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill_stroke src, threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_line()
+    src = 'strokeWeight 100; line 100, 200, 500, 600'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_rect()
+    src = 'rect 100, 200, 300, 400'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_rect_with_rectMode()
+    assert_p5_draw 'rectMode CORNER;  rect 100, 200, 300, 400'
+    assert_p5_draw 'rectMode CORNERS; rect 100, 200, 300, 500'
+    assert_p5_draw 'rectMode CENTER;  rect 400, 500, 300, 400'
+    assert_p5_draw 'rectMode RADIUS;  rect 400, 500, 300, 400'
+  end
+
+  def test_ellipse()
+    src = 'ellipse 500, 600, 300, 400'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_ellipse_with_ellipseMode()
+    assert_p5_draw 'ellipseMode CORNER;  ellipse 100, 200, 300, 400'
+    assert_p5_draw 'ellipseMode CORNERS; ellipse 100, 200, 300, 500'
+    assert_p5_draw 'ellipseMode CENTER;  ellipse 400, 500, 300, 400'
+    assert_p5_draw 'ellipseMode RADIUS;  ellipse 400, 500, 300, 400'
+  end
+
+  def test_circle()
+    src = 'circle 500, 600, 300'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_circle_with_ellipseMode()
+    assert_p5_draw 'ellipseMode CORNER;  circle 100, 200, 300'
+    assert_p5_draw 'ellipseMode CORNERS; circle 100, 200, 300'
+    assert_p5_draw 'ellipseMode CENTER;  circle 400, 500, 300'
+    assert_p5_draw 'ellipseMode RADIUS;  circle 400, 500, 300'
+  end
+
+  def test_arc()
+    src = 'arc 500, 600, 300, 400, PI * 0.25, PI * 0.75'
+    assert_p5_fill        src, threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill_stroke src, threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_arc_with_ellipseMode()
+    assert_p5_draw 'ellipseMode CORNER;  arc 100, 200, 300, 400, 0, PI * 0.75',
+      threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_draw 'ellipseMode CORNERS; arc 100, 200, 300, 500, 0, PI * 0.75',
+      threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_draw 'ellipseMode CENTER;  arc 400, 500, 300, 400, 0, PI * 0.75',
+      threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_draw 'ellipseMode RADIUS;  arc 400, 500, 300, 400, 0, PI * 0.75',
+      threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_square()
+    src = 'square 500, 600, 300'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_triangle()
+    src = 'triangle 100,100, 100,500, 500,200'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_quad()
+    src = 'quad 100,100, 100,500, 500,500, 600,100'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  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
+  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
+  end
+
+  def test_shape_with_shapeMode_corner()
+    header = 'noStroke'
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 100, 200, 300, 400
+    EXPECTED
+      shapeMode CORNER
+      shape createShape(RECT, 100, 200, 300, 400)
+    ACTUAL
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 100, 200, 300, 400
+    EXPECTED
+      shapeMode CORNER
+      shape createShape(RECT, 0, 0, 300, 400), 100, 200
+    ACTUAL
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 100, 200, 300, 400
+    EXPECTED
+      shapeMode CORNER
+      shape createShape(RECT, 0, 0, 500, 600), 100, 200, 300, 400
+    ACTUAL
+  end
+
+  def test_shape_with_shapeMode_corners()
+    header = 'noStroke'
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 100, 200, 300, 400
+    EXPECTED
+      shapeMode CORNERS
+      shape createShape(RECT, 100, 200, 300, 400)
+    ACTUAL
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 100, 200, 200, 200
+    EXPECTED
+      shapeMode CORNERS
+      shape createShape(RECT, 0, 0, 300, 400), 100, 200
+    ACTUAL
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 100, 200, 200, 200
+    EXPECTED
+      shapeMode CORNERS
+      shape createShape(RECT, 0, 0, 500, 600), 100, 200, 300, 400
+    ACTUAL
+  end
+
+  def test_shape_with_shapeMode_center()
+    header = 'noStroke'
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 400, 400, 200, 400
+    EXPECTED
+      shapeMode CENTER
+      shape createShape(RECT, 500, 600, 200, 400)
+    ACTUAL
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 400, 400, 200, 400
+    EXPECTED
+      shapeMode CENTER
+      shape createShape(RECT, 0, 0, 200, 400), 500, 600
+    ACTUAL
+
+    assert_equal_draw header, <<~EXPECTED, <<~ACTUAL
+      rect 400, 400, 200, 400
+    EXPECTED
+      shapeMode CENTER
+      shape createShape(RECT, 0, 0, 700, 800), 500, 600, 200, 400
+    ACTUAL
+  end
+
+  def test_shape_with_groups()
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      rect 100, 100, 300, 200
+      rect 200, 200, 300, 200
+    EXPECTED
+      group = createShape GROUP
+      group.addChild createShape(RECT, 100, 100, 300, 200)
+      group.addChild createShape(RECT, 200, 200, 300, 200)
+      shape group
+    ACTUAL
+
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      rect 100, 100, 300, 200
+      rect 200, 200, 300, 200
+    EXPECTED
+      group1 = createShape GROUP
+      group2 = createShape GROUP
+      group1.addChild createShape(RECT, 100, 100, 300, 200)
+      group1.addChild group2
+      group2.addChild createShape(RECT, 200, 200, 300, 200)
+      shape group1
+    ACTUAL
+  end
+
+  def test_shape_with_non_groups()
+    assert_equal_draw '', <<~ACTUAL
+      s = createShape
+      s.addChild createShape(RECT, 100, 100, 300, 200)
+      s.addChild createShape(RECT, 200, 200, 300, 200)
+      shape s
+    ACTUAL
+  end
+
+  def test_beginShape_points()
+    src = <<~END
+      strokeWeight 200
+      beginShape POINTS
+      vertex 200, 300
+      vertex 500, 600
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill_stroke src, 'endShape', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_beginShape_lines()
+    src = <<~END
+      strokeWeight 200
+      beginShape LINES
+      vertex 100, 200
+      vertex 300, 400
+      vertex 500, 600
+      vertex 700, 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'
+  end
+
+  def test_beginShape_triangles()
+    src = <<~END
+      beginShape TRIANGLES
+      vertex 100, 100
+      vertex 100, 500
+      vertex 400, 200
+      vertex 500, 100
+      vertex 500, 500
+      vertex 900, 200
+    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_beginShape_triangle_fan()
+    src = <<~END
+      beginShape TRIANGLE_FAN
+      vertex 100, 100
+      vertex 100, 500
+      vertex 200, 600
+      vertex 300, 500
+      vertex 400, 600
+      vertex 500, 200
+      vertex 400, 100
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape', threshold: 0.98
+    assert_p5_fill_stroke src, 'endShape', threshold: 0.98
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE', threshold: 0.98
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: 0.98
+  end
+
+  def test_beginShape_triangle_strip()
+    src = <<~END
+      beginShape TRIANGLE_STRIP
+      vertex 100, 100
+      vertex 100, 900
+      vertex 500, 200
+      vertex 500, 800
+      vertex 900, 100
+      vertex 900, 900
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_beginShape_quads()
+    src = <<~END
+      beginShape QUADS
+      vertex 100, 100
+      vertex 200, 500
+      vertex 300, 400
+      vertex 400, 200
+      vertex 500, 100
+      vertex 600, 500
+      vertex 700, 400
+      vertex 800, 200
+    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_beginShape_quad_strip()
+    src = <<~END
+      beginShape QUAD_STRIP
+      vertex 100, 100
+      vertex 100, 500
+      vertex 500, 200
+      vertex 500, 400
+      vertex 900, 100
+      vertex 900, 500
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_beginShape_tess()
+    src = <<~END
+      beginShape TESS
+      vertex 100, 100
+      vertex 100, 500
+      vertex 500, 500
+      vertex 500, 400
+      vertex 300, 400
+      vertex 300, 300
+      vertex 500, 300
+      vertex 500, 100
+    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_beginShape_polygon()
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      vertex 100, 500
+      vertex 500, 500
+      vertex 500, 400
+      vertex 300, 400
+      vertex 300, 300
+      vertex 500, 300
+      vertex 500, 100
+    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_lerp()
     g = graphics
 
@@ -93,4 +491,52 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_equal c[ 70, 80, 90], g.lerpColor(c[10, 20, 30], c[50, 60, 70],  1.5)
   end
 
-end# TestGraphics
+  def test_createShape_line()
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      line 100, 200, 800, 900
+    EXPECTED
+      shape createShape(LINE, 100, 200, 800, 900)
+    ACTUAL
+  end
+
+  def test_createShape_rect()
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      rect 100, 200, 500, 600
+    EXPECTED
+      shape createShape(RECT, 100, 200, 500, 600)
+    ACTUAL
+  end
+
+  def test_createShape_ellipse()
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      ellipse 500, 600, 300, 400
+    EXPECTED
+      shape createShape(ELLIPSE, 500, 600, 300, 400)
+    ACTUAL
+  end
+
+  def test_createShape_arc()
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      arc 500, 600, 300, 400, 0, PI / 2
+    EXPECTED
+      shape createShape(ARC, 500, 600, 300, 400, 0, PI / 2)
+    ACTUAL
+  end
+
+  def test_createShape_triangle()
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      triangle 100,100, 100,500, 400,200
+    EXPECTED
+      shape createShape(TRIANGLE, 100,100, 100,500, 400,200)
+    ACTUAL
+  end
+
+  def test_createShape_quad()
+    assert_equal_draw <<~EXPECTED, <<~ACTUAL
+      quad 100,100, 100,500, 500,500, 600,100
+    EXPECTED
+      shape createShape(QUAD, 100,100, 100,500, 500,500, 600,100)
+    ACTUAL
+  end
+
+end# TestGraphicsContext