rubysketch 0.3.3 → 0.3.8

data/rubysketch.gemspec

@@ -28,17 +28,9 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '~> 2'
 
-  s.add_runtime_dependency 'yard'
-  s.add_runtime_dependency 'xot',       '~> 0.1'
-  s.add_runtime_dependency 'beeps',     '~> 0.1'
-  s.add_runtime_dependency 'rucy',      '~> 0.1'
-  s.add_runtime_dependency 'rays',      '~> 0.1'
   s.add_runtime_dependency 'reflexion', '~> 0.1'
 
   s.files            = `git ls-files`.split $/
   s.test_files       = s.files.grep %r{^(test|spec|features)/}
   s.extra_rdoc_files = rdocs.to_a
-  s.has_rdoc         = true
-
-  s.extensions << 'Rakefile'
 end

data/test/helper.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+
+%w[../xot ../rucy ../rays ../reflex .]
+  .map  {|s| File.expand_path "../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'test/unit'
+require 'xot/test'
+require 'rubysketch'
+
+include Xot::Test
+
+
+unless $RAYS_NOAUTOINIT
+  #def Rays.fin! () 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
+  assert_in_delta v1.z, v2.z, delta
+end

data/test/processing/test_utility.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative '../helper'
+
+
+class TestProcessingUtility < Test::Unit::TestCase
+
+  class Context
+    include RubySketch::Processing::Context
+  end
+
+  def context
+    Context.new
+  end
+
+  def test_random ()
+    c = context
+
+    assert_equal Float,  c.random(1).class
+    assert_equal Float,  c.random(1.0).class
+    assert_equal Symbol, c.random((:a..:z).to_a).class
+
+    assert_not_equal c.random, c.random
+
+    10000.times do
+      n = c.random
+      assert 0 <= n && n < 1
+
+      n = c.random 1
+      assert 0 <= n && n < 1
+
+      n = c.random 1, 2
+      assert 1.0 <= n && n < 2.0
+    end
+  end
+
+end# TestProcessingUtility

data/test/processing/test_vector.rb

@@ -6,7 +6,9 @@ require_relative '../helper'
 
 class TestProcessingVector < Test::Unit::TestCase
 
-  V = RubySketch::Processing::Vector
+  P = RubySketch::Processing
+
+  V = P::Vector
 
   M = Math
 
@@ -21,76 +23,76 @@ class TestProcessingVector < Test::Unit::TestCase
   end
 
   def test_initialize ()
-    assert_equal vec(0, 0, 0), vec()
-    assert_equal vec(1, 0, 0), vec(1)
-    assert_equal vec(1, 2, 0), vec(1, 2)
-    assert_equal vec(1, 2, 3), vec(1, 2, 3)
+    assert_equal_vector vec(0, 0, 0), vec()
+    assert_equal_vector vec(1, 0, 0), vec(1)
+    assert_equal_vector vec(1, 2, 0), vec(1, 2)
+    assert_equal_vector vec(1, 2, 3), vec(1, 2, 3)
 
-    assert_equal vec(0, 0, 0), vec([])
-    assert_equal vec(1, 0, 0), vec([1])
-    assert_equal vec(1, 2, 0), vec([1, 2])
-    assert_equal vec(1, 2, 3), vec([1, 2, 3])
+    assert_equal_vector vec(0, 0, 0), vec([])
+    assert_equal_vector vec(1, 0, 0), vec([1])
+    assert_equal_vector vec(1, 2, 0), vec([1, 2])
+    assert_equal_vector vec(1, 2, 3), vec([1, 2, 3])
 
-    assert_equal vec(1, 2, 3), vec(vec 1, 2, 3)
-    assert_equal vec(1, 2, 3), vec(point 1, 2, 3)
+    assert_equal_vector vec(1, 2, 3), vec(vec 1, 2, 3)
+    assert_equal_vector vec(1, 2, 3), vec(point 1, 2, 3)
   end
 
   def test_set ()
     v0 = vec 9, 9, 9
 
-    v = v0.dup; v.set;         assert_equal vec(0, 0, 0), v
-    v = v0.dup; v.set 1;       assert_equal vec(1, 0, 0), v
-    v = v0.dup; v.set 1, 2;    assert_equal vec(1, 2, 0), v
-    v = v0.dup; v.set 1, 2, 3; assert_equal vec(1, 2, 3), v
+    v = v0.dup; v.set;         assert_equal_vector vec(0, 0, 0), v
+    v = v0.dup; v.set 1;       assert_equal_vector vec(1, 0, 0), v
+    v = v0.dup; v.set 1, 2;    assert_equal_vector vec(1, 2, 0), v
+    v = v0.dup; v.set 1, 2, 3; assert_equal_vector vec(1, 2, 3), v
 
-    v = v0.dup; v.set [];        assert_equal vec(0, 0, 0), v
-    v = v0.dup; v.set [1];       assert_equal vec(1, 0, 0), v
-    v = v0.dup; v.set [1, 2];    assert_equal vec(1, 2, 0), v
-    v = v0.dup; v.set [1, 2, 3]; assert_equal vec(1, 2, 3), v
+    v = v0.dup; v.set [];        assert_equal_vector vec(0, 0, 0), v
+    v = v0.dup; v.set [1];       assert_equal_vector vec(1, 0, 0), v
+    v = v0.dup; v.set [1, 2];    assert_equal_vector vec(1, 2, 0), v
+    v = v0.dup; v.set [1, 2, 3]; assert_equal_vector vec(1, 2, 3), v
 
-    v = v0.dup; v.set   vec(1, 2, 3); assert_equal vec(1, 2, 3), v
-    v = v0.dup; v.set point(1, 2, 3); assert_equal vec(1, 2, 3), v
+    v = v0.dup; v.set   vec(1, 2, 3); assert_equal_vector vec(1, 2, 3), v
+    v = v0.dup; v.set point(1, 2, 3); assert_equal_vector vec(1, 2, 3), v
   end
 
   def test_dup ()
     v1 = vec 1, 2, 3
-    assert_equal vec(1, 2, 3), v1
+    assert_equal_vector vec(1, 2, 3), v1
 
     v2 = v1.dup
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(1, 2, 3), v2
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(1, 2, 3), v2
 
     v1.set 7, 8, 9
-    assert_equal vec(7, 8, 9), v1
-    assert_equal vec(1, 2, 3), v2
+    assert_equal_vector vec(7, 8, 9), v1
+    assert_equal_vector vec(1, 2, 3), v2
   end
 
   def test_copy ()
     v1 = vec 1, 2, 3
-    assert_equal vec(1, 2, 3), v1
+    assert_equal_vector vec(1, 2, 3), v1
 
     v2 = v1.copy
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(1, 2, 3), v2
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(1, 2, 3), v2
 
     v1.set 7, 8, 9
-    assert_equal vec(7, 8, 9), v1
-    assert_equal vec(1, 2, 3), v2
+    assert_equal_vector vec(7, 8, 9), v1
+    assert_equal_vector vec(1, 2, 3), v2
   end
 
   def test_xyz ()
     v = vec 1, 2, 3
-    assert_equal vec(1, 2, 3), v
-    assert_equal [1, 2, 3], [v.x, v.y, v.z]
+    assert_equal_vector vec(1, 2, 3), v
+    assert_equal           [1, 2, 3], [v.x, v.y, v.z]
 
     v.x = 7
-    assert_equal vec(7, 2, 3), v
+    assert_equal_vector vec(7, 2, 3), v
 
     v.y = 8
-    assert_equal vec(7, 8, 3), v
+    assert_equal_vector vec(7, 8, 3), v
 
     v.z = 9
-    assert_equal vec(7, 8, 9), v
+    assert_equal_vector vec(7, 8, 9), v
   end
 
   def test_array ()
@@ -100,135 +102,135 @@ class TestProcessingVector < Test::Unit::TestCase
   def test_add ()
     v = vec 1, 2, 3
     v.add 4, 5, 6
-    assert_equal vec(5, 7, 9), v
+    assert_equal_vector vec(5, 7, 9), v
 
-    assert_equal vec(1, 2, 3), vec(1, 2, 3).add()
-    assert_equal vec(5, 2, 3), vec(1, 2, 3).add(4)
-    assert_equal vec(5, 7, 3), vec(1, 2, 3).add(4, 5)
-    assert_equal vec(5, 7, 9), vec(1, 2, 3).add(4, 5, 6)
+    assert_equal_vector vec(1, 2, 3), vec(1, 2, 3).add()
+    assert_equal_vector vec(5, 2, 3), vec(1, 2, 3).add(4)
+    assert_equal_vector vec(5, 7, 3), vec(1, 2, 3).add(4, 5)
+    assert_equal_vector vec(5, 7, 9), vec(1, 2, 3).add(4, 5, 6)
 
-    assert_equal vec(1, 2, 3), vec(1, 2, 3).add([])
-    assert_equal vec(5, 2, 3), vec(1, 2, 3).add([4])
-    assert_equal vec(5, 7, 3), vec(1, 2, 3).add([4, 5])
-    assert_equal vec(5, 7, 9), vec(1, 2, 3).add([4, 5, 6])
+    assert_equal_vector vec(1, 2, 3), vec(1, 2, 3).add([])
+    assert_equal_vector vec(5, 2, 3), vec(1, 2, 3).add([4])
+    assert_equal_vector vec(5, 7, 3), vec(1, 2, 3).add([4, 5])
+    assert_equal_vector vec(5, 7, 9), vec(1, 2, 3).add([4, 5, 6])
 
-    assert_equal vec(5, 7, 9), vec(1, 2, 3).add(  vec(4, 5, 6))
-    assert_equal vec(5, 7, 9), vec(1, 2, 3).add(point(4, 5, 6))
+    assert_equal_vector vec(5, 7, 9), vec(1, 2, 3).add(  vec(4, 5, 6))
+    assert_equal_vector vec(5, 7, 9), vec(1, 2, 3).add(point(4, 5, 6))
   end
 
   def test_sub ()
     v = vec 9, 8, 7
     v.sub 1, 2, 3
-    assert_equal vec(8, 6, 4), v
+    assert_equal_vector vec(8, 6, 4), v
 
-    assert_equal vec(9, 8, 7), vec(9, 8, 7).sub()
-    assert_equal vec(8, 8, 7), vec(9, 8, 7).sub(1)
-    assert_equal vec(8, 6, 7), vec(9, 8, 7).sub(1, 2)
-    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub(1, 2, 3)
+    assert_equal_vector vec(9, 8, 7), vec(9, 8, 7).sub()
+    assert_equal_vector vec(8, 8, 7), vec(9, 8, 7).sub(1)
+    assert_equal_vector vec(8, 6, 7), vec(9, 8, 7).sub(1, 2)
+    assert_equal_vector vec(8, 6, 4), vec(9, 8, 7).sub(1, 2, 3)
 
-    assert_equal vec(9, 8, 7), vec(9, 8, 7).sub([])
-    assert_equal vec(8, 8, 7), vec(9, 8, 7).sub([1])
-    assert_equal vec(8, 6, 7), vec(9, 8, 7).sub([1, 2])
-    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub([1, 2, 3])
+    assert_equal_vector vec(9, 8, 7), vec(9, 8, 7).sub([])
+    assert_equal_vector vec(8, 8, 7), vec(9, 8, 7).sub([1])
+    assert_equal_vector vec(8, 6, 7), vec(9, 8, 7).sub([1, 2])
+    assert_equal_vector vec(8, 6, 4), vec(9, 8, 7).sub([1, 2, 3])
 
-    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub(  vec(1, 2, 3))
-    assert_equal vec(8, 6, 4), vec(9, 8, 7).sub(point(1, 2, 3))
+    assert_equal_vector vec(8, 6, 4), vec(9, 8, 7).sub(  vec(1, 2, 3))
+    assert_equal_vector vec(8, 6, 4), vec(9, 8, 7).sub(point(1, 2, 3))
   end
 
   def test_mult ()
     v = vec 1, 2, 3
     v.mult 2
-    assert_equal vec(2, 4, 6), v
+    assert_equal_vector vec(2, 4, 6), v
   end
 
   def test_div ()
     v = vec 2, 4, 6
     v.div 2
-    assert_equal vec(1, 2, 3), v
+    assert_equal_vector vec(1, 2, 3), v
   end
 
   def test_op_add ()
     v1 = vec 1, 2, 3
     v2 = vec 4, 5, 6
-    assert_equal vec(5, 7, 9), v1 + v2
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(4, 5, 6), v2
+    assert_equal_vector vec(5, 7, 9), v1 + v2
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(4, 5, 6), v2
 
-    assert_equal vec(5, 2, 3), vec(1, 2, 3) + 4
+    assert_equal_vector vec(5, 2, 3), vec(1, 2, 3) + 4
 
-    assert_equal vec(1, 2, 3), vec(1, 2, 3) + []
-    assert_equal vec(5, 2, 3), vec(1, 2, 3) + [4]
-    assert_equal vec(5, 7, 3), vec(1, 2, 3) + [4, 5]
-    assert_equal vec(5, 7, 9), vec(1, 2, 3) + [4, 5, 6]
+    assert_equal_vector vec(1, 2, 3), vec(1, 2, 3) + []
+    assert_equal_vector vec(5, 2, 3), vec(1, 2, 3) + [4]
+    assert_equal_vector vec(5, 7, 3), vec(1, 2, 3) + [4, 5]
+    assert_equal_vector vec(5, 7, 9), vec(1, 2, 3) + [4, 5, 6]
 
-    assert_equal vec(5, 7, 9), vec(1, 2, 3) +   vec(4, 5, 6)
-    assert_equal vec(5, 7, 9), vec(1, 2, 3) + point(4, 5, 6)
+    assert_equal_vector vec(5, 7, 9), vec(1, 2, 3) +   vec(4, 5, 6)
+    assert_equal_vector vec(5, 7, 9), vec(1, 2, 3) + point(4, 5, 6)
   end
 
   def test_op_sub ()
     v1 = vec 9, 8, 7
     v2 = vec 1, 2, 3
-    assert_equal vec(8, 6, 4), v1 - v2
-    assert_equal vec(9, 8, 7), v1
-    assert_equal vec(1, 2, 3), v2
+    assert_equal_vector vec(8, 6, 4), v1 - v2
+    assert_equal_vector vec(9, 8, 7), v1
+    assert_equal_vector vec(1, 2, 3), v2
 
-    assert_equal vec(8, 8, 7), vec(9, 8, 7) - 1
+    assert_equal_vector vec(8, 8, 7), vec(9, 8, 7) - 1
 
-    assert_equal vec(9, 8, 7), vec(9, 8, 7) - []
-    assert_equal vec(8, 8, 7), vec(9, 8, 7) - [1]
-    assert_equal vec(8, 6, 7), vec(9, 8, 7) - [1, 2]
-    assert_equal vec(8, 6, 4), vec(9, 8, 7) - [1, 2, 3]
+    assert_equal_vector vec(9, 8, 7), vec(9, 8, 7) - []
+    assert_equal_vector vec(8, 8, 7), vec(9, 8, 7) - [1]
+    assert_equal_vector vec(8, 6, 7), vec(9, 8, 7) - [1, 2]
+    assert_equal_vector vec(8, 6, 4), vec(9, 8, 7) - [1, 2, 3]
 
-    assert_equal vec(8, 6, 4), vec(9, 8, 7) -   vec(1, 2, 3)
-    assert_equal vec(8, 6, 4), vec(9, 8, 7) - point(1, 2, 3)
+    assert_equal_vector vec(8, 6, 4), vec(9, 8, 7) -   vec(1, 2, 3)
+    assert_equal_vector vec(8, 6, 4), vec(9, 8, 7) - point(1, 2, 3)
   end
 
   def test_op_mult ()
     v = vec 1, 2, 3
-    assert_equal vec(2, 4, 6), v * 2
-    assert_equal vec(1, 2, 3), v
+    assert_equal_vector vec(2, 4, 6), v * 2
+    assert_equal_vector vec(1, 2, 3), v
   end
 
   def test_op_div ()
     v = vec 2, 4, 6
-    assert_equal vec(1, 2, 3), v / 2
-    assert_equal vec(2, 4, 6), v
+    assert_equal_vector vec(1, 2, 3), v / 2
+    assert_equal_vector vec(2, 4, 6), v
   end
 
   def test_fun_add ()
     v1     = vec 1, 2, 3
     v2     = vec 4, 5, 6
     result = vec
-    assert_equal vec(5, 7, 9), V.add(v1, v2, result)
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(4, 5, 6), v2
-    assert_equal vec(5, 7, 9), result
+    assert_equal_vector vec(5, 7, 9), V.add(v1, v2, result)
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(4, 5, 6), v2
+    assert_equal_vector vec(5, 7, 9), result
   end
 
   def test_fun_sub ()
     v1     = vec 9, 8, 7
     v2     = vec 1, 2, 3
     result = vec
-    assert_equal vec(8, 6, 4), V.sub(v1, v2, result)
-    assert_equal vec(9, 8, 7), v1
-    assert_equal vec(1, 2, 3), v2
-    assert_equal vec(8, 6, 4), result
+    assert_equal_vector vec(8, 6, 4), V.sub(v1, v2, result)
+    assert_equal_vector vec(9, 8, 7), v1
+    assert_equal_vector vec(1, 2, 3), v2
+    assert_equal_vector vec(8, 6, 4), result
   end
 
   def test_fun_mult ()
     v1     = vec 1, 2, 3
     result = vec
-    assert_equal vec(2, 4, 6), V.mult(v1, 2, result)
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(2, 4, 6), result
+    assert_equal_vector vec(2, 4, 6), V.mult(v1, 2, result)
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(2, 4, 6), result
   end
 
   def test_fun_div ()
     v1     = vec 2, 4, 6
     result = vec
-    assert_equal vec(1, 2, 3), V.div(v1, 2, result)
-    assert_equal vec(2, 4, 6), v1
-    assert_equal vec(1, 2, 3), result
+    assert_equal_vector vec(1, 2, 3), V.div(v1, 2, result)
+    assert_equal_vector vec(2, 4, 6), v1
+    assert_equal_vector vec(1, 2, 3), result
   end
 
   def test_mag ()
@@ -243,27 +245,27 @@ class TestProcessingVector < Test::Unit::TestCase
 
   def test_setMag ()
     v = vec 3, 4, 0
-    assert_equal vec(6, 8, 0), v.setMag(10)
-    assert_equal vec(6, 8, 0), v
+    assert_equal_vector vec(6, 8, 0), v.setMag(10)
+    assert_equal_vector vec(6, 8, 0), v
 
     v      = vec 3, 4, 0
     result = vec
-    assert_equal vec(6, 8, 0), v.setMag(result, 10)
-    assert_equal vec(3, 4, 0), v
-    assert_equal vec(6, 8, 0), result
+    assert_equal_vector vec(6, 8, 0), v.setMag(result, 10)
+    assert_equal_vector vec(3, 4, 0), v
+    assert_equal_vector vec(6, 8, 0), result
   end
 
   def test_normalize ()
     v      = vec 1, 2, 3
     normal = v / v.mag
-    assert_equal normal, v.normalize
-    assert_equal normal, v
+    assert_equal_vector normal, v.normalize
+    assert_equal_vector normal, v
 
     v      = vec 1, 2, 3
     result = vec
-    assert_equal normal,       v.normalize(result)
-    assert_equal vec(1, 2, 3), v
-    assert_equal normal,       result
+    assert_equal_vector normal,       v.normalize(result)
+    assert_equal_vector vec(1, 2, 3), v
+    assert_equal_vector normal,       result
   end
 
   def test_limit ()
@@ -282,12 +284,12 @@ class TestProcessingVector < Test::Unit::TestCase
     v2 = vec 4, 5, 6
 
     assert_in_delta M.sqrt((4-1)**2 + (5-2)**2 + (6-3)**2), v1.dist(v2), 0.000001
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(4, 5, 6), v2
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(4, 5, 6), v2
 
     assert_in_delta M.sqrt((4-1)**2 + (5-2)**2 + (6-3)**2), V.dist(v1, v2), 0.000001
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(4, 5, 6), v2
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(4, 5, 6), v2
   end
 
   def test_dot ()
@@ -295,55 +297,55 @@ class TestProcessingVector < Test::Unit::TestCase
     v2 = vec 4, 5, 6
 
     assert_equal 1*4 + 2*5 + 3*6, v1.dot(4, 5, 6)
-    assert_equal vec(1, 2, 3), v1
+    assert_equal_vector vec(1, 2, 3), v1
 
     assert_equal 1*4 + 2*5 + 3*6, v1.dot(v2)
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(4, 5, 6), v2
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(4, 5, 6), v2
 
     assert_equal 1*4 + 2*5 + 3*6, V.dot(v1, v2)
-    assert_equal vec(1, 2, 3), v1
-    assert_equal vec(4, 5, 6), v2
+    assert_equal_vector vec(1, 2, 3), v1
+    assert_equal_vector vec(4, 5, 6), v2
   end
 
   def test_cross ()
     v1 = vec 1, 0, 0
     v2 = vec 0, 1, 0
 
-    assert_equal vec(0, 0, 1), v1.cross(0, 1, 0)
-    assert_equal vec(1, 0, 0), v1
+    assert_equal_vector vec(0, 0, 1), v1.cross(0, 1, 0)
+    assert_equal_vector vec(1, 0, 0), v1
 
     result = vec 1, 2, 3
-    assert_equal vec(0, 0, 1), v1.cross(v2, result)
-    assert_equal vec(1, 0, 0), v1
-    assert_equal vec(0, 1, 0), v2
-    assert_equal vec(0, 0, 1), result
+    assert_equal_vector vec(0, 0, 1), v1.cross(v2, result)
+    assert_equal_vector vec(1, 0, 0), v1
+    assert_equal_vector vec(0, 1, 0), v2
+    assert_equal_vector vec(0, 0, 1), result
 
     result = vec 1, 2, 3
-    assert_equal vec(0, 0, 1), V.cross(v1, v2, result)
-    assert_equal vec(1, 0, 0), v1
-    assert_equal vec(0, 1, 0), v2
-    assert_equal vec(0, 0, 1), result
+    assert_equal_vector vec(0, 0, 1), V.cross(v1, v2, result)
+    assert_equal_vector vec(1, 0, 0), v1
+    assert_equal_vector vec(0, 1, 0), v2
+    assert_equal_vector vec(0, 0, 1), result
   end
 
   def test_rotate ()
     angle   = PI * 2 * 0.1
-    context = Object.new.tap {|o| def o.toAngle__ (angle); angle; end}
+    context = Object.new.tap {|o| def o.toAngle__ (a); a * 2 * P::RAD2DEG__; end}
 
     v = vec 1, 0, 0
-    assert_equal vec(M.cos(angle), M.sin(angle), 0), v.rotate(angle)
-    assert_equal vec(M.cos(angle), M.sin(angle), 0), v
+    assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), v.rotate(angle)
+    assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), v
 
     v = vec 1, 0, 0, context: context
-    assert_equal vec(M.cos(angle), M.sin(angle), 0), v.rotate(36)
+    assert_equal_vector vec(M.cos(angle * 2), M.sin(angle * 2), 0), v.rotate(angle)
   end
 
   def test_fromAngle ()
     angle  = PI * 2 * 0.1
     result = vec
-    assert_equal vec(M.cos(angle), M.sin(angle), 0), V.fromAngle(angle)
-    assert_equal vec(M.cos(angle), M.sin(angle), 0), V.fromAngle(angle, result)
-    assert_equal vec(M.cos(angle), M.sin(angle), 0), result
+    assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), V.fromAngle(angle)
+    assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), V.fromAngle(angle, result)
+    assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), result
   end
 
   def test_heading ()
@@ -359,9 +361,9 @@ class TestProcessingVector < Test::Unit::TestCase
   end
 
   def test_lerp ()
-    assert_equal vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(vec(1, 1, 1),    0.5)
-    assert_equal vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(    1, 1, 1,     0.5)
-    assert_equal vec(0.5, 0.5, 0.5), V.lerp(vec(0, 0, 0), vec(1, 1, 1), 0.5)
+    assert_equal_vector vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(vec(1, 1, 1),    0.5)
+    assert_equal_vector vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(    1, 1, 1,     0.5)
+    assert_equal_vector vec(0.5, 0.5, 0.5), V.lerp(vec(0, 0, 0), vec(1, 1, 1), 0.5)
   end
 
   def test_random2D ()