picrate 0.0.2-java

data/test/sketches/library/my_library/my_library.rb

@@ -0,0 +1,32 @@
+# This class demonstrates how by inheriting from the abstract class LibraryProxy
+# we can access 'keyEvent' and 'draw'  (Note we need a draw method even
+# though can be empty)
+class MyLibrary < LibraryProxy
+  java_import 'processing.event.KeyEvent'
+
+  attr_reader :app
+
+  def initialize(parent)
+    @app = parent
+  end
+
+  def draw # optional
+    fill app.color(200, 0, 0, 100)
+    app.rect 100, 100, 60, 90
+  end
+
+  # favor guard clause no_op unless key pressed
+  # and no_op unless ascii key
+  def keyEvent(e) # NB: need camel case for reflection to work
+    return unless e.get_action == KeyEvent::PRESS
+    return if e.get_key > 122 # else we can't use :chr
+    case e.get_key.chr.upcase
+    when 'S'
+      app.send :hide, false
+    when 'H'
+      app.send :hide, true
+    else
+      puts e.get_key.chr
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+gem 'minitest'
+require 'minitest/pride'
+require 'minitest/autorun'

data/test/vecmath_spec_test.rb

@@ -0,0 +1,522 @@
+require_relative 'test_helper'
+require 'java'
+require_relative '../lib/picrate'
+
+Java::Monkstone::PicrateLibrary.load(JRuby.runtime)
+
+
+Dir.chdir(File.dirname(__FILE__))
+
+class VecmathTest < Minitest::Test
+
+  # duck for Vec2D constructor
+  Point = Struct.new(:x, :y)
+  # duck for Vec3D constructor
+  Point3 = Struct.new(:x, :y, :z)
+  # non-duck to test fail
+  Pointless = Struct.new(:a, :b)
+  # non-duck to test fail
+  Pointless3 = Struct.new(:a, :b, :c)
+  def setup
+
+  end
+
+  def test_equals
+    x, y = 1.0000001, 1.01
+    a = Vec2D.new(x, y)
+    assert_equal(a.to_a, [x, y], 'Failed to return Vec2D as an Array')
+  end
+
+  def test_not_equals
+    a = Vec2D.new(3, 5)
+    b = Vec2D.new(6, 7)
+    refute_equal(a, b, 'Failed equals false')
+  end
+
+  def test_copy_equals
+    x, y = 1.0000001, 1.01
+    a = Vec2D.new(x, y)
+    b = a.copy
+    assert_equal(a.to_a, b.to_a, 'Failed deep copy')
+  end
+
+  def test_constructor_float
+    val = Point.new(1.0, 8.0) # duck type
+    expected = Vec2D.new(val)
+    assert_equal(expected, Vec2D.new(1.0, 8.0), 'Failed duck type constructor floats')
+  end
+
+  def test_constructor_fixnum
+    val = Point.new(1, 8) # duck type fixnum
+    expected = Vec2D.new(val)
+    assert_equal(expected, Vec2D.new(1.0, 8.0), 'Failed duck type constructor fixnum')
+  end
+
+  def test_failed_duck_type
+    val = Pointless.new(1.0, 8.0) # non duck type
+    assert_raises TypeError do
+      Vec2D.new(val)
+    end
+  end
+
+  def test_copy_not_equals
+    x, y = 1.0000001, 1.01
+    a = Vec2D.new(x, y)
+    b = a.copy
+    b *= 0
+    refute_equal(a.to_a, b.to_a, 'Failed deep copy')
+  end
+
+  def test_equals_when_close
+    a = Vec2D.new(3.0000000, 5.00000)
+    b = Vec2D.new(3.0000000, 5.000001)
+    assert_equal(a, b, 'Failed to return equal when v. close')
+  end
+
+  def test_sum
+    a = Vec2D.new(3, 5)
+    b = Vec2D.new(6, 7)
+    c = Vec2D.new(9, 12)
+    assert_equal(a + b, c, 'Failed to sum vectors')
+  end
+
+  def test_subtract
+    a = Vec2D.new(3, 5)
+    b = Vec2D.new(6, 7)
+    c = Vec2D.new(-3, -2)
+    assert_equal(a - b, c, 'Failed to subtract vectors')
+  end
+
+  def test_multiply
+    a = Vec2D.new(3, 5)
+    b = 2
+    c = a * b
+    d = Vec2D.new(6, 10)
+    assert_equal(c, d, 'Failed to multiply vector by scalar')
+  end
+
+  def test_divide
+    a = Vec2D.new(3, 5)
+    b = 2
+    c = Vec2D.new(1.5, 2.5)
+    d = a / b
+    assert_equal(c, d, 'Failed to divide vector by scalar')
+  end
+
+  def test_dot
+    a = Vec2D.new(3, 5)
+    b = Vec2D.new(6, 7)
+    assert_in_epsilon(a.dot(b), 53, 0.001, 'Failed to dot product')
+  end
+
+  def test_self_dot
+    a = Vec2D.new(3, 5)
+    assert_in_epsilon(a.dot(a), 34, 0.001, 'Failed self dot product')
+  end
+
+  def test_from_angle
+    a = Vec2D.from_angle(Math::PI * 0.75)
+    assert_equal(a, Vec2D.new(-1 * Math.sqrt(0.5), Math.sqrt(0.5)), 'Failed to create vector from angle')
+  end
+
+  def test_random
+    a = Vec2D.random
+    assert a.kind_of? Vec2D
+    assert_in_epsilon(a.mag, 1.0)
+  end
+
+  def test_assign_value
+    a = Vec2D.new(3, 5)
+    a.x = 23
+    assert_equal(a.x, 23, 'Failed to assign x value')
+  end
+
+  def test_mag
+    a = Vec2D.new(-3, -4)
+    assert_in_epsilon(a.mag, 5, 0.001,'Failed to return magnitude of vector')
+  end
+
+  def test_mag_variant
+    a = Vec2D.new(3.0, 2)
+    b = Math.sqrt(3.0**2 + 2**2)
+    assert_in_epsilon(a.mag, b, 0.001, 'Failed to return magnitude of vector')
+  end
+
+  def test_mag_zero_one
+    a = Vec2D.new(-1, 0)
+    assert_in_epsilon(a.mag, 1, 0.001, 'Failed to return magnitude of vector')
+  end
+
+  def test_dist
+    a = Vec2D.new(3, 5)
+    b = Vec2D.new(6, 7)
+    assert_in_epsilon(a.dist(b), Math.sqrt(3.0**2 + 2**2), 0.001, 'Failed to return distance between two vectors')
+  end
+
+  def test_lerp
+    a = Vec2D.new(1, 1)
+    b = Vec2D.new(3, 3)
+    assert_equal(a.lerp(b, 0.5), Vec2D.new(2, 2), 'Failed to return lerp between two vectors')
+  end
+
+  def test_lerp_exception
+    a = Vec2D.new(1, 1)
+    b = Vec2D.new(3, 3)
+    assert_raises SyntaxError do
+      a.lerp(b, 0.5, 0.5)
+    end
+  end
+
+  def test_lerp_unclamped
+    a = Vec2D.new(1, 1)
+    b = Vec2D.new(3, 3)
+    assert_equal(a.lerp(b, 5), Vec2D.new(11, 11), 'Failed to return lerp between two vectors')
+  end
+
+  def test_lerp!
+    a = Vec2D.new(1, 1)
+    b = Vec2D.new(3, 3)
+    a.lerp!(b, 0.5)
+    assert_equal(a, Vec2D.new(2, 2), 'Failed to return lerp! between two vectors')
+  end
+
+  def test_lerp_unclamped!
+    a = Vec2D.new(1, 1)
+    b = Vec2D.new(3, 3)
+    a.lerp!(b, 5)
+    assert_equal(a, Vec2D.new(11, 11), 'Failed to return lerp! between two vectors')
+  end
+
+  def test_set_mag
+    a = Vec2D.new(1, 1)
+    assert_equal(a.set_mag(Math.sqrt(32)), Vec2D.new(4, 4), 'Failed to set_mag vector')
+  end
+
+  def test_set_mag_block
+    a = Vec2D.new(1, 1)
+    assert_equal(a.set_mag(Math.sqrt(32)) { true }, Vec2D.new(4, 4), 'Failed to set_mag_block true vector')
+  end
+
+  def test_set_mag_block_false
+    a = Vec2D.new(1, 1)
+    assert_equal(a.set_mag(Math.sqrt(32)) { false }, Vec2D.new(1, 1), 'Failed to set_mag_block true vector')
+  end
+
+  def test_plus_assign
+    a = Vec2D.new(3, 5)
+    b = Vec2D.new(6, 7)
+    a += b
+    assert_equal(a, Vec2D.new(9, 12), 'Failed to += assign')
+  end
+
+  def test_normalize
+    a = Vec2D.new(3, 5)
+    b = a.normalize
+    assert_in_epsilon(b.mag, 1, 0.001, 'Failed to return a normalized vector')
+  end
+
+  def test_normalize!
+    a = Vec2D.new(3, 5)
+    a.normalize!
+    assert_in_epsilon(a.mag, 1, 0.001, 'Failed to return a normalized! vector')
+  end
+
+  def test_heading
+    a = Vec2D.new(1, 1)
+    assert_in_epsilon(a.heading, Math::PI / 4.0, 0.001, 'Failed to return heading in radians')
+  end
+
+  def test_rotate
+    x, y = 20, 10
+    b = Vec2D.new(x, y)
+    a = b.rotate(Math::PI / 2)
+    assert_equal(a, Vec2D.new(-10, 20), 'Failed to rotate vector by scalar radians')
+  end
+
+  def test_hash_index
+    x, y = 10, 20
+    b = Vec2D.new(x, y)
+    assert_equal(b[:x], x, 'Failed to hash index')
+  end
+
+  def test_hash_set
+    x = 10
+    b = Vec2D.new
+    b[:x] = x
+    assert_equal(b, Vec2D.new(x, 0), 'Failed to hash assign')
+  end
+
+  def test_inspect
+    a = Vec2D.new(3, 2.000000000000001)
+    assert_equal(a.inspect, 'Vec2D(x = 3.0000, y = 2.0000)')
+  end
+
+  def test_array_reduce
+    array = [Vec2D.new(1, 2), Vec2D.new(10, 2), Vec2D.new(1, 2)]
+    sum = array.reduce(Vec2D.new) { |c, d| c + d }
+    assert_equal(sum, Vec2D.new(12, 6))
+  end
+
+  def test_array_zip
+    one = [Vec2D.new(1, 2), Vec2D.new(10, 2), Vec2D.new(1, 2)]
+    two = [Vec2D.new(1, 2), Vec2D.new(10, 2), Vec2D.new(1, 2)]
+    zipped = one.zip(two).flatten
+    expected = [Vec2D.new(1, 2), Vec2D.new(1, 2), Vec2D.new(10, 2), Vec2D.new(10, 2), Vec2D.new(1, 2), Vec2D.new(1, 2)]
+    assert_equal(zipped, expected)
+  end
+
+  def test_cross_area # NB: the sign might be negative
+    a = Vec2D.new(200, 0)
+    b = Vec2D.new(0, 200)
+    # Expected result is an area, twice that of the triangle created by the vectors
+    assert_equal((a).cross(b).abs, 40_000.0, 'Failed area test using 2D vector cross product')
+  end
+
+  def test_cross_non_zero # Could be used to calculate area of triangle
+    a = Vec2D.new(40, 40)
+    b = Vec2D.new(40, 140)
+    c = Vec2D.new(140, 40)
+    assert_equal((a - b).cross(b - c).abs / 2, 5_000.0, 'Failed area calculation using 2D vector cross product')
+  end
+
+  def test_cross_zero # where a, b, c are collinear area == 0
+    a = Vec2D.new(0, 0)
+    b = Vec2D.new(100, 100)
+    c = Vec2D.new(200, 200)
+    # see http://mathworld.wolfram.com/Collinear.html for details
+    assert((a - b).cross(b - c).zero?, 'Failed collinearity test using 2D vector cross product')
+  end
+
+  def test_equals3
+    x, y, z = 1.0000001, 1.01, 0.0
+    a = Vec3D.new(x, y)
+    assert_equal(a.to_a, [x, y, z], 'Failed to return Vec3D as an Array')
+  end
+
+  def test_constructor_float3
+    val = Point3.new(1.0, 8.0, 7.0) # duck type
+    expected = Vec3D.new(val)
+    assert_equal(expected, Vec3D.new(1.0, 8.0, 7.0), 'Failed duck type constructor floats')
+  end
+
+  def test_constructor_fixnum3
+    val = Point3.new(1, 8, 7) # duck type fixnum
+    expected = Vec3D.new(val)
+    assert_equal(expected, Vec3D.new(1.0, 8.0, 7.0), 'Failed duck type constructor fixnum')
+  end
+
+  def test_failed_duck_type3
+    val = Pointless3.new(1.0, 8.0, 7.0) # non duck type
+    assert_raises TypeError do
+      Vec3D.new(val)
+    end
+  end
+
+  def test_not_equals3
+    a = Vec3D.new(3, 5, 1)
+    b = Vec3D.new(6, 7, 1)
+    refute_equal(a, b, 'Failed equals false')
+  end
+
+  def test_copy_equals3
+    x, y, z = 1.0000001, 1.01, 1
+    a = Vec3D.new(x, y, z)
+    b = a.copy
+    assert_equal(a.to_a, b.to_a, 'Failed deep copy')
+  end
+
+  def test_copy_not_equals3
+    x, y, z = 1.0000001, 1.01, 6.0
+    a = Vec3D.new(x, y, z)
+    b = a.copy
+    b *= 0
+    refute_equal(a.to_a, b.to_a, 'Failed deep copy')
+  end
+
+  def test_equals_when_close3
+    a = Vec3D.new(3.0000000, 5.00000, 2)
+    b = Vec3D.new(3.0000000, 5.000001, 2)
+    assert_equal(a, b, 'Failed to return equal when v. close')
+  end
+
+  def test_sum3
+    a = Vec3D.new(3, 5, 1)
+    b = Vec3D.new(6, 7, 1)
+    c = Vec3D.new(9, 12, 2)
+    assert_equal(a + b, c, 'Failed to sum vectors')
+  end
+
+  def test_subtract3
+    a = Vec3D.new(3, 5, 0)
+    b = Vec3D.new(6, 7, 1)
+    c = Vec3D.new(-3, -2, -1)
+    assert_equal(a - b, c, 'Failed to subtract vectors')
+  end
+
+  def test_multiply3
+    a = Vec3D.new(3, 5, 1)
+    b = 2
+    c = a * b
+    d = Vec3D.new(6, 10, 2)
+    assert_equal(c, d, 'Failed to multiply vector by scalar')
+  end
+
+  def test_divide3
+    a = Vec3D.new(3, 5, 4)
+    b = 2
+    c = Vec3D.new(1.5, 2.5, 2)
+    d = a / b
+    assert_equal(c, d, 'Failed to divide vector by scalar')
+  end
+
+  def test_random3
+    a = Vec3D.random
+    assert a.kind_of? Vec3D
+    assert_in_epsilon(a.mag, 1.0)
+  end
+
+  def test_assign_value3
+    a = Vec3D.new(3, 5)
+    a.x=23
+    assert_equal(a.x, 23, 'Failed to assign x value')
+  end
+
+  def test_mag3
+    a = Vec3D.new(-3, -4)
+    assert_equal(a.mag, 5, 'Failed to return magnitude of vector')
+  end
+
+  def test_mag_variant3
+    a = Vec3D.new(3.0, 2)
+    b = Math.sqrt(3.0**2 + 2**2)
+    assert_in_epsilon(a.mag, b, 0.001, 'Failed to return magnitude of vector')
+  end
+
+  def test_mag_zero_one3
+    a = Vec3D.new(-1, 0)
+    assert_equal(a.mag, 1, 'Failed to return magnitude of vector')
+  end
+
+  def test_dist3
+    a = Vec3D.new(3, 5, 2)
+    b = Vec3D.new(6, 7, 1)
+    message = 'Failed to return distance between two vectors'
+    assert_equal(a.dist(b), Math.sqrt(3.0**2 + 2**2 + 1), message)
+  end
+
+  def test_dist_squared3
+    a = Vec3D.new(3, 5, 2)
+    b = Vec3D.new(6, 7, 1)
+    message = 'Failed to return distance squared between two vectors'
+    assert_equal(a.dist_squared(b), 3.0**2 + 2**2 + 1, message)
+  end
+
+  def test_dot3
+    a = Vec3D.new(10, 20, 0)
+    b = Vec3D.new(60, 80, 0)
+    assert_in_epsilon(a.dot(b), 2200.0, 0.001, 'Failed to dot product')
+  end
+
+  def test_self_dot3
+    a = Vec3D.new(10, 20, 4)
+    assert_in_epsilon(a.dot(a), 516.0, 0.001, 'Failed to self dot product')
+  end
+
+  def test_cross3
+    a = Vec3D.new(3, 5, 2)
+    b = Vec3D.new(6, 7, 1)
+    c = Vec3D.new(-9.0, 9.0, -9.0)
+    assert_equal(a.cross(b), c, 'Failed cross product')
+  end
+
+  def test_set_mag3
+    a = Vec3D.new(1, 1)
+    assert_equal(a.set_mag(Math.sqrt(32)), Vec3D.new(4, 4), 'Failed to set_mag vector')
+  end
+
+  def test_set_mag_block3
+    a = Vec3D.new(1, 1)
+    assert_equal(a.set_mag(Math.sqrt(32)) { true }, Vec3D.new(4, 4), 'Failed to set_mag_block true vector')
+  end
+
+  def test_set_mag_block_false3
+    a = Vec3D.new(1, 1)
+    assert_equal(a.set_mag(Math.sqrt(32)) { false }, Vec3D.new(1, 1), 'Failed to set_mag_block true vector')
+  end
+
+  def test_plus_assign3
+    a = Vec3D.new(3, 5)
+    b = Vec3D.new(6, 7)
+    a += b
+    assert_equal(a, Vec3D.new(9, 12), 'Failed to += assign')
+  end
+
+  def test_normalize3
+    a = Vec3D.new(3, 5)
+    b = a.normalize
+    assert_in_epsilon(b.mag, 1, 0.001, 'Failed to return a normalized vector')
+  end
+
+  def test_normalize3!
+    a = Vec3D.new(3, 5)
+    a.normalize!
+    assert_in_epsilon(a.mag, 1, 0.001, 'Failed to return a normalized! vector')
+  end
+
+  def test_inspect3
+    a = Vec3D.new(3, 2.000000000000001, 1)
+    assert_equal(a.inspect, 'Vec3D(x = 3.0000, y = 2.0000, z = 1.0000)')
+  end
+
+  def test_array_reduce3
+    array = [Vec3D.new(1, 2), Vec3D.new(10, 2), Vec3D.new(1, 2)]
+    sum = array.reduce(Vec3D.new) { |c, d| c + d }
+    assert_equal(sum, Vec3D.new(12, 6))
+  end
+
+  def test_array_zip3
+    one = [Vec3D.new(1, 2), Vec3D.new(10, 2), Vec3D.new(1, 2)]
+    two = [Vec3D.new(1, 2), Vec3D.new(10, 2), Vec3D.new(1, 2)]
+    zipped = one.zip(two).flatten
+    expected = [Vec3D.new(1, 2), Vec3D.new(1, 2), Vec3D.new(10, 2), Vec3D.new(10, 2), Vec3D.new(1, 2), Vec3D.new(1, 2)]
+    assert_equal(zipped, expected)
+  end
+
+  def test_eql3?
+    a = Vec3D.new(3.0, 5.0, 0)
+    b = Vec3D.new(3.0, 5.0, 0)
+    assert(a.eql?(b))
+  end
+
+  def test_not_eql3?
+    a = Vec3D.new(3.0, 5.0, 0)
+    b = Vec3D.new(3.0, 5.000001, 0)
+    refute(a.eql?(b))
+  end
+
+  def test_equal3?
+    a = Vec3D.new(3.0, 5.0, 0)
+    assert(a.equal?(a))
+  end
+
+  def test_not_equal3?
+    a = Vec3D.new(3.0, 5.0, 0)
+    b = Vec3D.new(3.0, 5.0, 0)
+    refute(a.equal?(b))
+  end
+
+  def test_hash_key3
+    x, y, z = 10, 20, 50
+    b = Vec3D.new(x, y, z)
+    assert_equal(b[:x], x, 'Failed hash key access')
+    assert_equal(b[:y], y, 'Failed hash key access')
+    assert_equal(b[:z], z, 'Failed hash key access')
+  end
+
+  def test_hash_set3
+    x = 10
+    b = Vec3D.new
+    b[:x] = x
+    assert_equal(b, Vec3D.new(x, 0, 0), 'Failed to hash assign')
+  end
+end