fxruby 1.6.14-universal-darwin-9

data/tests/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/tests/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

data/tests/TC_FXViewport.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXViewport < Test::Unit::TestCase
+  def setup
+    @viewport = FXViewport.new
+  end
+
+  def testAttributes
+    assert(@viewport.w)
+    assert_kind_of(Integer, @viewport.w)
+    assert(@viewport.h)
+    assert_kind_of(Integer, @viewport.h)
+    assert(@viewport.left)
+    assert_kind_of(Float, @viewport.left)
+    assert(@viewport.right)
+    assert_kind_of(Float, @viewport.right)
+    assert(@viewport.bottom)
+    assert_kind_of(Float, @viewport.bottom)
+    assert(@viewport.top)
+    assert_kind_of(Float, @viewport.top)
+    assert(@viewport.hither)
+    assert_kind_of(Float, @viewport.hither)
+    assert(@viewport.yon)
+    assert_kind_of(Float, @viewport.yon)
+  end
+end

data/tests/TC_FXXBMIcon.rb

@@ -0,0 +1,15 @@
+require 'fox16'
+require 'test/unit'
+require 'testcase'
+
+include Fox
+
+class TC_FXXBMIcon < TestCase
+  def setup
+    super(self.class.name)
+  end
+
+  def test_fileExt
+    assert_equal("xbm", FXXBMIcon.fileExt)
+  end
+end

data/tests/TC_FXXBMImage.rb

@@ -0,0 +1,15 @@
+require 'fox16'
+require 'test/unit'
+require 'testcase'
+
+include Fox
+
+class TC_FXXBMImage < TestCase
+  def setup
+    super(self.class.name)
+  end
+
+  def test_fileExt
+    assert_equal("xbm", FXXBMImage.fileExt)
+  end
+end

data/tests/TC_FXXPMIcon.rb

@@ -0,0 +1,15 @@
+require 'fox16'
+require 'test/unit'
+require 'testcase'
+
+include Fox
+
+class TC_FXXPMIcon < TestCase
+  def setup
+    super(self.class.name)
+  end
+
+  def test_fileExt
+    assert_equal("xpm", FXXPMIcon.fileExt)
+  end
+end

data/tests/TC_FXXPMImage.rb

@@ -0,0 +1,15 @@
+require 'fox16'
+require 'test/unit'
+require 'testcase'
+
+include Fox
+
+class TC_FXXPMImage < TestCase
+  def setup
+    super(self.class.name)
+  end
+
+  def test_fileExt
+    assert_equal("xpm", FXXPMImage.fileExt)
+  end
+end

data/tests/TC_Misc.rb

@@ -0,0 +1,157 @@
+require 'test/unit'
+
+require 'fox16'
+
+class TC_Misc < Test::Unit::TestCase
+
+  DELTA = 1.0e-5
+
+  def test_MKUINT
+    assert_equal(0, Fox.MKUINT(Fox::MINKEY, Fox::MINTYPE))
+    assert_equal(65535, Fox.MKUINT(Fox::MAXKEY, Fox::MINTYPE))
+    assert_equal(4294901760, Fox.MKUINT(Fox::MINKEY, Fox::MAXTYPE))
+    assert_equal(4294967295, Fox.MKUINT(Fox::MAXKEY, Fox::MAXTYPE))
+  end
+
+  def test_FXSEL
+    assert_equal(0, Fox.FXSEL(Fox::MINTYPE, Fox::MINKEY))
+    assert_equal(65535, Fox.FXSEL(Fox::MINTYPE, Fox::MAXKEY))
+    assert_equal(4294901760, Fox.FXSEL(Fox::MAXTYPE, Fox::MINKEY))
+    assert_equal(4294967295, Fox.FXSEL(Fox::MAXTYPE, Fox::MAXKEY))
+  end
+
+  def test_FXSELTYPE
+    assert_equal(Fox::MINTYPE, Fox.FXSELTYPE(0))
+    assert_equal(Fox::MINTYPE, Fox.FXSELTYPE(65535))
+    assert_equal(Fox::MAXTYPE, Fox.FXSELTYPE(4294901760))
+    assert_equal(Fox::MAXTYPE, Fox.FXSELTYPE(4294967295))
+  end
+
+  def test_FXSELID
+    assert_equal(Fox::MINKEY, Fox.FXSELID(0))
+    assert_equal(Fox::MAXKEY, Fox.FXSELID(65535))
+    assert_equal(Fox::MINKEY, Fox.FXSELID(4294901760))
+    assert_equal(Fox::MAXKEY, Fox.FXSELID(4294967295))
+  end
+
+  def test_FXRGB
+    # result depends on endian-ness of platform!
+  end
+
+  def test_FXRGBA
+    # result depends on endian-ness of platform!
+  end
+
+  def test_FXREDVAL
+    assert_equal(1, Fox.FXREDVAL(Fox.FXRGB(1, 0, 0)))
+  end
+
+  def test_FXGREENVAL
+    assert_equal(1, Fox.FXGREENVAL(Fox.FXRGB(0, 1, 0)))
+  end
+
+  def test_FXBLUEVAL
+    assert_equal(1, Fox.FXBLUEVAL(Fox.FXRGB(0, 0, 1)))
+  end
+
+  def test_FXALPHAVAL
+    assert_equal(1, Fox.FXALPHAVAL(Fox.FXRGBA(0, 0, 0, 1)))
+  end
+
+  def test_FXRGBACOMPVAL
+    clr = Fox.FXRGBA(0, 1, 2, 3)
+    0.upto(3) { |i|
+      assert_equal(i, Fox.FXRGBACOMPVAL(clr, i))
+    }
+  end
+
+  def test_fxparseAccel
+  end
+
+  def test_fxparseHotKey
+  end
+
+  def test_fxfindhotkeyoffset
+  end
+
+  def test_makeHiliteColor
+  end
+
+  def test_makeShadowColor
+  end
+
+  def test_fxcolorfromname
+  end
+
+  def test_fxnamefromcolor
+  end
+
+  def test_fxhsv_to_rgb
+    h, s, v = 180.0, 0.0, 1.0
+    r, g, b = Fox.fxhsv_to_rgb(h, s, v)
+    assert_in_delta(v, r, DELTA)
+    assert_in_delta(v, g, DELTA)
+    assert_in_delta(v, b, DELTA)
+
+    h, s, v = 180.0, 0.5, 1.0
+    r, g, b = Fox.fxhsv_to_rgb(h, s, v)
+    assert_in_delta(0.5, r, DELTA)
+    assert_in_delta(1.0, g, DELTA)
+    assert_in_delta(1.0, b, DELTA)
+
+    h, s, v = 0.0, 0.5, 1.0
+    r, g, b = Fox.fxhsv_to_rgb(h, s, v)
+    assert_in_delta(1.0, r, DELTA)
+    assert_in_delta(0.5, g, DELTA)
+    assert_in_delta(0.5, b, DELTA)
+
+    h, s, v = 360.0, 0.5, 1.0
+    r, g, b = Fox.fxhsv_to_rgb(h, s, v)
+    assert_in_delta(1.0, r, DELTA)
+    assert_in_delta(0.5, g, DELTA)
+    assert_in_delta(0.5, b, DELTA)
+  end
+
+  def test_fxrgb_to_hsv
+    r, g, b = 0.0, 0.0, 0.0
+    h, s, v = Fox.fxrgb_to_hsv(r, g, b)
+    assert_in_delta(0.0, h, DELTA)
+    assert_in_delta(0.0, s, DELTA)
+    assert_in_delta(0.0, v, DELTA)
+
+    r, g, b = 0.5, 0.5, 0.5
+    h, s, v = Fox.fxrgb_to_hsv(r, g, b)
+    assert_in_delta(0.0, h, DELTA)
+    assert_in_delta(0.0, s, DELTA)
+    assert_in_delta(0.5, v, DELTA)
+
+    r, g, b = 1.0, 0.0, 0.0
+    h, s, v = Fox.fxrgb_to_hsv(r, g, b)
+    assert_in_delta(0.0, h, DELTA)
+    assert_in_delta(1.0, s, DELTA)
+    assert_in_delta(1.0, v, DELTA)
+
+    r, g, b = 0.0, 1.0, 0.0
+    h, s, v = Fox.fxrgb_to_hsv(r, g, b)
+    assert_in_delta(120.0, h, DELTA)
+    assert_in_delta(1.0, s, DELTA)
+    assert_in_delta(1.0, v, DELTA)
+
+    r, g, b = 0.0, 0.0, 1.0
+    h, s, v = Fox.fxrgb_to_hsv(r, g, b)
+    assert_in_delta(240.0, h, DELTA)
+    assert_in_delta(1.0, s, DELTA)
+    assert_in_delta(1.0, v, DELTA)
+  end
+  
+  def test_fxversion
+    assert_instance_of(String, Fox.fxversion)
+  end
+  
+  def test_fxrubyversion
+    assert_instance_of(String, Fox.fxrubyversion)
+  end
+
+  def test_fxTraceLevel
+  end
+end

data/tests/TC_downcast.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'fox16'
+require 'testcase'
+
+include Fox
+
+class TC_downcast < TestCase
+  def setup
+    super(self.class.name)
+  end
+  def test_downcast
+    fs = FXFileSelector.new(mainWindow)
+    assert_kind_of(FXHorizontalFrame, fs.first)
+  end
+end

data/tests/TS_All.rb

@@ -0,0 +1,25 @@
+require 'fox16'
+require 'test/unit'
+
+class TS_All
+  def TS_All.suite
+    suite = Test::Unit::TestSuite.new
+    Object.constants.sort.each do |k|
+      next if /^TC_/ !~ k
+      constant = Object.const_get(k)
+      if constant.kind_of?(Class)
+#       puts "adding tests for #{constant.to_s}"
+	suite << constant.suite
+      end
+    end
+    suite
+  end
+end
+
+if __FILE__ == $0
+  require 'test/unit/ui/console/testrunner'
+  Dir.glob("TC_*.rb").each do |testcase|
+    require "#{testcase}"
+  end
+  Test::Unit::UI::Console::TestRunner.run(TS_All)
+end