fxruby 1.6.20-universal-darwin-10

data/test/TC_FXVec2f.rb

@@ -0,0 +1,137 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXVec2f < Test::Unit::TestCase
+
+  def test_default_constructor
+    FXVec4f.new
+  end
+
+  def test_copy_constructor
+    vec = FXVec2f.new(2.0, 3.0)
+    assert_equal(vec, FXVec2f.new(vec)) # also tests the '==' method!
+  end
+
+  def test_construct_from_components
+    vec = FXVec2f.new(2.0, 3.0)
+    assert_equal(2.0, vec[0])
+    assert_equal(2.0, vec.x)
+    assert_equal(3.0, vec[1])
+    assert_equal(3.0, vec.y)
+  end
+  
+  def test_getitem
+    vec = FXVec2f.new(2.0, 3.0)
+    assert_equal(2.0, vec[0])
+    assert_equal(3.0, vec[1])
+  end
+
+  def test_setitem
+    vec = FXVec2f.new(2.0, 3.0)
+    vec[0] = 1.0
+    vec[1] = 4.0
+    assert_equal(1.0, vec[0])
+    assert_equal(4.0, vec[1])
+  end
+
+  def test_bounds_checks
+    vec = FXVec2f.new
+    assert_raises(IndexError) { vec[-1] }
+    assert_raises(IndexError) { vec[2] }
+    assert_raises(IndexError) { vec[-1] = 0.0 }
+    assert_raises(IndexError) { vec[2] = 0.0 }
+  end
+
+  def test_unary_minus
+    vec = -FXVec2f.new(1.0, 2.0)
+    assert_equal(vec[0], -1.0)
+    assert_equal(vec[1], -2.0)
+  end
+
+  def test_add
+    a = FXVec2f.new(1.0, 2.0)
+    b = FXVec2f.new(2.0, 4.0)
+    c = FXVec2f.new(3.0, 6.0)
+    assert_equal(c, a + b)
+  end
+
+  def test_subtract
+    a = FXVec2f.new(3.0, 6.0)
+    b = FXVec2f.new(2.0, 4.0)
+    c = FXVec2f.new(1.0, 2.0)
+    assert_equal(c, a - b)
+  end
+
+  def test_multiply_by_scalar
+    v1 = FXVec2f.new(3.0,  6.0)
+    v2 = FXVec2f.new(6.0, 12.0)
+    assert_equal(v2, v1*2)
+  end
+
+  def test_dot_product
+    v1 = FXVec2f.new(3.0, 6.0)
+    v2 = FXVec2f.new(2.0, 4.0)
+    assert_equal(30.0, v1*v2)
+    assert_equal(30.0, v2*v1)
+    assert_equal(30.0, v1.dot(v2))
+    assert_equal(30.0, v2.dot(v1))
+  end
+
+  def test_divide_by_scalar
+    v1 = FXVec2f.new(6.0, 12.0)
+    v2 = FXVec2f.new(3.0,  6.0)
+    assert_equal(v2, v1/2)
+      assert_raises(ZeroDivisionError) {
+      v1/0
+    }
+  end
+
+  def test_length
+    v = FXVec2f.new(1.0, 1.0)
+    assert_in_delta(Math.sqrt(2), v.length, 1.0e-7) 
+  end
+
+  def test_length2
+    v = FXVec2f.new(1.0, 1.0)
+    assert_equal(2.0, v.length2) 
+  end
+
+  def test_normalize
+    vec = FXVec2f.new(1.0, 1.0).normalize
+    assert_in_delta(1.0/Math.sqrt(2), vec.x, 1.0e-7)
+    assert_in_delta(1.0/Math.sqrt(2), vec.y, 1.0e-7)
+  end
+
+  def test_lo
+    v1 = FXVec2f.new(3.0, 2.0)
+    v2 = FXVec2f.new(2.0, 3.0)
+    assert_equal(v1.lo(v2), v2.lo(v1))
+    lo = v1.lo(v2)
+    assert_equal(2.0, lo.x)
+    assert_equal(2.0, lo.y)
+  end
+
+  def test_hi
+    v1 = FXVec2f.new(3.0, 2.0)
+    v2 = FXVec2f.new(2.0, 3.0)
+    assert_equal(v1.hi(v2), v2.hi(v1))
+    hi = v1.hi(v2)
+    assert_equal(3.0, hi.x)
+    assert_equal(3.0, hi.y)
+  end
+
+  def test_to_a
+    ary = FXVec2f.new(1.0, 1.0).to_a
+    assert_equal(Array, ary.class)
+    assert_equal(2, ary.length)
+    assert_equal(1.0, ary[0])
+    assert_equal(1.0, ary[1])
+  end
+
+  def test_equal
+    assert(FXVec2f.new(1.0, 2.0) == FXVec2f.new(1.0, 2.0))
+  end
+
+end

data/test/TC_FXVec3d.rb

@@ -0,0 +1,150 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXVec3d < Test::Unit::TestCase
+
+  def test_default_constructor
+    FXVec3d.new
+  end
+
+  def test_copy_constructor
+    vec = FXVec3d.new(1, 2, 3)
+    assert_equal(vec, FXVec3d.new(vec)) # also tests the '==' method!
+  end
+
+  def test_construct_from_components
+    vec = FXVec3d.new(1, 2, 3)
+    assert_equal(1, vec[0])
+    assert_equal(1, vec.x)
+    assert_equal(2, vec[1])
+    assert_equal(2, vec.y)
+    assert_equal(3, vec[2])
+    assert_equal(3, vec.z)
+  end
+  
+  def test_construct_from_color
+    vec = FXVec3d.new(FXRGB(1, 1, 1))
+    assert_in_delta(0.003921568627, vec.x, 1.0e-12)
+    assert_in_delta(0.003921568627, vec.y, 1.0e-12)
+    assert_in_delta(0.003921568627, vec.z, 1.0e-12)
+  end
+
+  def test_getitem
+    v = FXVec3d.new(1, 2, 3)
+    assert_equal(1, v[0])
+    assert_equal(2, v[1])
+    assert_equal(3, v[2])
+  end
+
+  def test_setitem
+    v = FXVec3d.new
+    assert_equal(1, v[0] = 1)
+    assert_equal(2, v[1] = 2)
+    assert_equal(3, v[2] = 3)
+  end
+  
+  def test_bounds_checks
+    vec = FXVec3d.new
+    assert_raises(IndexError) { vec[-1] }
+    assert_raises(IndexError) { vec[3]  }
+    assert_raises(IndexError) { vec[-1] = 0.0 }
+    assert_raises(IndexError) { vec[3]  = 0.0 }
+  end
+  
+  def test_unary_minus
+    assert_equal(FXVec3d.new(-1, -2, -3), -FXVec3d.new(1, 2, 3))
+  end
+
+  def test_add
+    a = FXVec3d.new(1, 2, 3)
+    b = FXVec3d.new(2, 4, 6)
+    c = FXVec3d.new(3, 6, 9)
+    assert_equal(c, a + b)
+  end
+
+  def test_subtract
+    a = FXVec3d.new(3, 6, 9)
+    b = FXVec3d.new(2, 4, 6)
+    c = FXVec3d.new(1, 2, 3)
+    assert_equal(c, a - b)
+  end
+
+  def test_multiply_by_scalar
+    v1 = FXVec3d.new(3, 6, 9)
+    v2 = FXVec3d.new(6, 12, 18)
+    assert_equal(v2, v1*2)
+  end
+
+  def test_divide_by_scalar
+    v1 = FXVec3d.new(6, 12, 18)
+    v2 = FXVec3d.new(3, 6, 9)
+    assert_equal(v2, v1/2)
+      assert_raises(ZeroDivisionError) {
+      v1/0
+    }
+  end
+
+  def test_dot_product
+    v1 = FXVec3d.new(1, 2, 3)
+    v2 = FXVec3d.new(1, 2, 3)
+    assert_equal(14, v1*v2)
+    assert_equal(14, v2*v1)
+    assert_equal(14, v1.dot(v2))
+    assert_equal(14, v2.dot(v1))
+  end
+
+  def test_cross_product
+  end
+
+  def test_length
+    v = FXVec3d.new(1, 1, 1)
+    assert_in_delta(Math.sqrt(3), v.length, 1.0e-12) 
+  end
+
+  def test_length2
+    v = FXVec3d.new(1, 1, 1)
+    assert_equal(3, v.length2) 
+  end
+
+  def test_normalize
+    vec = FXVec3d.new(1, 1, 1).normalize
+    assert_in_delta(1/Math.sqrt(3), vec.x, 1.0e-12)
+    assert_in_delta(1/Math.sqrt(3), vec.y, 1.0e-12)
+    assert_in_delta(1/Math.sqrt(3), vec.z, 1.0e-12)
+  end
+
+  def test_lo
+    v1 = FXVec3d.new(3, 2, 1)
+    v2 = FXVec3d.new(1, 2, 3)
+    assert_equal(v1.lo(v2), v2.lo(v1))
+    lo = v1.lo(v2)
+    assert_equal(1, lo.x)
+    assert_equal(2, lo.y)
+    assert_equal(1, lo.z)
+  end
+
+  def test_hi
+    v1 = FXVec3d.new(1, 2, 3)
+    v2 = FXVec3d.new(3, 2, 1)
+    assert_equal(v1.hi(v2), v2.hi(v1))
+    hi = v1.hi(v2)
+    assert_equal(3, hi.x)
+    assert_equal(2, hi.y)
+    assert_equal(3, hi.z)
+  end
+
+  def test_to_a
+    ary = FXVec3d.new(1, 1, 1).to_a
+    assert_equal(Array, ary.class)
+    assert_equal(3, ary.length)
+    assert_equal(1, ary[0])
+    assert_equal(1, ary[1])
+    assert_equal(1, ary[2])
+  end
+
+  def test_equal
+    assert(FXVec3d.new(1, 2, 3) == FXVec3d.new(1, 2, 3))
+  end
+end

data/test/TC_FXVec3f.rb

@@ -0,0 +1,150 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXVec3f < Test::Unit::TestCase
+
+  def test_default_constructor
+    FXVec3f.new
+  end
+
+  def test_copy_constructor
+    vec = FXVec3f.new(1, 2, 3)
+    assert_equal(vec, FXVec3f.new(vec)) # also tests the '==' method!
+  end
+
+  def test_construct_from_components
+    vec = FXVec3f.new(1, 2, 3)
+    assert_equal(1, vec[0])
+    assert_equal(1, vec.x)
+    assert_equal(2, vec[1])
+    assert_equal(2, vec.y)
+    assert_equal(3, vec[2])
+    assert_equal(3, vec.z)
+  end
+  
+  def test_construct_from_color
+    vec = FXVec3f.new(FXRGB(1, 1, 1))
+    assert_in_delta(0.003921568627,  vec.x, 1.0e-7)
+    assert_in_delta(0.003921568627, vec.y, 1.0e-7)
+    assert_in_delta(0.003921568627, vec.z, 1.0e-7)
+  end
+
+  def test_getitem
+    v = FXVec3f.new(1, 2, 3)
+    assert_equal(1, v[0])
+    assert_equal(2, v[1])
+    assert_equal(3, v[2])
+  end
+
+  def test_setitem
+    v = FXVec3f.new
+    assert_equal(1, v[0] = 1)
+    assert_equal(2, v[1] = 2)
+    assert_equal(3, v[2] = 3)
+  end
+  
+  def test_bounds_checks
+    vec = FXVec3f.new
+    assert_raises(IndexError) { vec[-1] }
+    assert_raises(IndexError) { vec[3]  }
+    assert_raises(IndexError) { vec[-1] = 0.0 }
+    assert_raises(IndexError) { vec[3]  = 0.0 }
+  end
+  
+  def test_unary_minus
+    assert_equal(FXVec3f.new(-1, -2, -3), -FXVec3f.new(1, 2, 3))
+  end
+
+  def test_add
+    a = FXVec3f.new(1, 2, 3)
+    b = FXVec3f.new(2, 4, 6)
+    c = FXVec3f.new(3, 6, 9)
+    assert_equal(c, a + b)
+  end
+
+  def test_subtract
+    a = FXVec3f.new(3, 6, 9)
+    b = FXVec3f.new(2, 4, 6)
+    c = FXVec3f.new(1, 2, 3)
+    assert_equal(c, a - b)
+  end
+
+  def test_multiply_by_scalar
+    v1 = FXVec3f.new(3, 6, 9)
+    v2 = FXVec3f.new(6, 12, 18)
+    assert_equal(v2, v1*2)
+  end
+
+  def test_divide_by_scalar
+    v1 = FXVec3f.new(6, 12, 18)
+    v2 = FXVec3f.new(3, 6, 9)
+    assert_equal(v2, v1/2)
+      assert_raises(ZeroDivisionError) {
+      v1/0
+    }
+  end
+
+  def test_dot_product
+    v1 = FXVec3f.new(1, 2, 3)
+    v2 = FXVec3f.new(1, 2, 3)
+    assert_equal(14, v1*v2)
+    assert_equal(14, v2*v1)
+    assert_equal(14, v1.dot(v2))
+    assert_equal(14, v2.dot(v1))
+  end
+
+  def test_cross_product
+  end
+
+  def test_length
+    v = FXVec3f.new(1, 1, 1)
+    assert_in_delta(Math.sqrt(3), v.length, 1.0e-7) 
+  end
+
+  def test_length2
+    v = FXVec3f.new(1, 1, 1)
+    assert_equal(3, v.length2) 
+  end
+
+  def test_normalize
+    vec = FXVec3f.new(1, 1, 1).normalize
+    assert_in_delta(1/Math.sqrt(3), vec.x, 1.0e-7)
+    assert_in_delta(1/Math.sqrt(3), vec.y, 1.0e-7)
+    assert_in_delta(1/Math.sqrt(3), vec.z, 1.0e-7)
+  end
+
+  def test_lo
+    v1 = FXVec3f.new(3, 2, 1)
+    v2 = FXVec3f.new(1, 2, 3)
+    assert_equal(v1.lo(v2), v2.lo(v1))
+    lo = v1.lo(v2)
+    assert_equal(1, lo.x)
+    assert_equal(2, lo.y)
+    assert_equal(1, lo.z)
+  end
+
+  def test_hi
+    v1 = FXVec3f.new(1, 2, 3)
+    v2 = FXVec3f.new(3, 2, 1)
+    assert_equal(v1.hi(v2), v2.hi(v1))
+    hi = v1.hi(v2)
+    assert_equal(3, hi.x)
+    assert_equal(2, hi.y)
+    assert_equal(3, hi.z)
+  end
+
+  def test_to_a
+    ary = FXVec3f.new(1, 1, 1).to_a
+    assert_equal(Array, ary.class)
+    assert_equal(3, ary.length)
+    assert_equal(1, ary[0])
+    assert_equal(1, ary[1])
+    assert_equal(1, ary[2])
+  end
+
+  def test_equal
+    assert(FXVec3f.new(1, 2, 3) == FXVec3f.new(1, 2, 3))
+  end
+end

data/test/TC_FXVec4f.rb

@@ -0,0 +1,158 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXVec4f < Test::Unit::TestCase
+
+  def test_new
+    FXVec4f.new
+  end
+  
+  def test_new2
+    vec1 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    assert_equal(vec1, FXVec4f.new(vec1))
+  end
+  
+  def test_new3
+    a = FXVec3f.new(1, 2, 3)
+    b = FXVec4f.new(a)
+    assert_equal(1, b[0])
+    assert_equal(2, b[1])
+    assert_equal(3, b[2])
+    assert_equal(1, b[3])
+  end
+  
+  def test_new4
+    a = FXVec4f.new(1, 2, 3)
+    assert_equal(1, a[0])
+    assert_equal(2, a[1])
+    assert_equal(3, a[2])
+    assert_equal(1, a[3])
+
+    b = FXVec4f.new(1, 2, 3, 4)
+    assert_equal(1, b[0])
+    assert_equal(2, b[1])
+    assert_equal(3, b[2])
+    assert_equal(4, b[3])
+  end
+  
+  def test_new5
+    c = FXVec4f.new(FXRGB(128, 128, 128))
+  end
+
+  def test_getitem
+    v = FXVec4f.new
+    assert_kind_of(Float, v[0])
+    assert_kind_of(Float, v[1])
+    assert_kind_of(Float, v[2])
+    assert_kind_of(Float, v[3])
+    assert_raises(IndexError) { v[-1] }
+    assert_raises(IndexError) { v[4] }
+  end
+
+  def test_setitem
+    v = FXVec4f.new
+    assert_kind_of(Float, v[0] = 0.0)
+    assert_kind_of(Float, v[1] = 0.0)
+    assert_kind_of(Float, v[2] = 0.0)
+    assert_kind_of(Float, v[3] = 0.0)
+    assert_raises(IndexError) { v[-1] = 0.0 }
+    assert_raises(IndexError) { v[4] = 0.0 }
+  end
+
+  def test_neg
+    vec = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    vec = -vec
+    assert_equal(vec[0], -1.0)
+    assert_equal(vec[1], -2.0)
+    assert_equal(vec[2], -3.0)
+    assert_equal(vec[3], -4.0)
+  end
+
+  def test_add
+    v1 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
+    v3 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
+    assert_equal(v3, v1 + v2)
+  end
+
+  def test_sub
+    v1 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
+    v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
+    v3 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    assert_equal(v3, v1 - v2)
+  end
+
+  def test_mul
+    v1 = FXVec4f.new(3.0,  6.0,  9.0, 12.0)
+    v2 = FXVec4f.new(6.0, 12.0, 18.0, 24.0)
+    assert_equal(v2, v1 * 2)
+  end
+  
+  def test_mul2 # same as dot product
+    v1 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
+    v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
+    assert_equal(180.0, v1*v2)
+    assert_equal(180.0, v2*v1)
+  end
+
+  def test_div
+    v1 = FXVec4f.new(6.0, 12.0, 18.0, 24.0)
+    v2 = FXVec4f.new(3.0,  6.0,  9.0, 12.0)
+    assert_equal(v2, v1/2)
+      assert_raises(ZeroDivisionError) {
+      v1/0
+    }
+  end
+
+  def test_dot
+    v1 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
+    v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
+    assert_equal(180.0, v1.dot(v2))
+    assert_equal(180.0, v2.dot(v1))
+  end
+
+  def test_length
+    v = FXVec4f.new(1.0, 1.0, 1.0, 1.0)
+    assert_equal(2.0, v.length) 
+  end
+
+  def test_normalize
+    vec = FXVec4f.new(1.0, 1.0, 1.0, 1.0)
+    assert_equal(FXVec4f.new(0.5, 0.5, 0.5, 0.5), vec.normalize)
+  end
+
+  def test_lo
+    v1 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    v2 = FXVec4f.new(2.0, 3.0, 4.0, 5.0)
+    assert_equal(v1, v1.lo(v2))
+    assert_equal(v1, v2.lo(v1))
+  end
+
+  def test_hi
+    v1 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    v2 = FXVec4f.new(2.0, 3.0, 4.0, 5.0)
+    assert_equal(v2, v1.hi(v2))
+    assert_equal(v2, v2.hi(v1))
+  end
+
+  def test_to_a
+    vec = FXVec4f.new(1.0, 1.0, 1.0)
+    arr = vec.to_a
+    assert_equal(Array, arr.class)
+    assert_equal(4, arr.length)
+    assert_equal(vec[0], arr[0])
+    assert_equal(vec[1], arr[1])
+    assert_equal(vec[2], arr[2])
+    assert_equal(vec[3], arr[3])
+  end
+
+  def test_equal
+    vec1 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    vec2 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
+    assert(vec1 == vec2)
+  end
+
+end