fxruby 1.6.20-x86-linux

data/test/TC_FXMaterial.rb

@@ -0,0 +1,89 @@
+require 'test/unit'
+
+require 'fox16'
+require 'fox16/glshapes'
+
+include Fox
+
+class TC_FXMaterial < Test::Unit::TestCase
+
+  DELTA = 1.0e-6
+  
+  def setup
+    @mat = FXMaterial.new
+  end
+  
+  def test_ambient
+    @mat.ambient = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.ambient[0], DELTA)
+    assert_in_delta(0.6, @mat.ambient[1], DELTA)
+    assert_in_delta(0.7, @mat.ambient[2], DELTA)
+    assert_in_delta(0.8, @mat.ambient[3], DELTA)
+
+    @mat.ambient = FXVec4f.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.ambient[0], DELTA)
+    assert_in_delta(0.6, @mat.ambient[1], DELTA)
+    assert_in_delta(0.7, @mat.ambient[2], DELTA)
+    assert_in_delta(0.8, @mat.ambient[3], DELTA)
+  end
+  
+  def test_diffuse
+    @mat.diffuse = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.diffuse[0], DELTA)
+    assert_in_delta(0.6, @mat.diffuse[1], DELTA)
+    assert_in_delta(0.7, @mat.diffuse[2], DELTA)
+    assert_in_delta(0.8, @mat.diffuse[3], DELTA)
+
+    @mat.diffuse = FXVec4f.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.diffuse[0], DELTA)
+    assert_in_delta(0.6, @mat.diffuse[1], DELTA)
+    assert_in_delta(0.7, @mat.diffuse[2], DELTA)
+    assert_in_delta(0.8, @mat.diffuse[3], DELTA)
+  end
+  
+  def test_emission
+    @mat.emission = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+
+    @mat.emission = FXHVec.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+  end
+  
+  def test_emission
+    @mat.emission = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+
+    @mat.emission = FXVec4f.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+  end
+  
+  def test_shininess
+    @mat.shininess = 0.5
+    assert_in_delta(0.5, @mat.shininess, DELTA)
+  end
+
+  def test_bug
+    cube = FXGLCube.new(0, 0, 0, 0, 0)
+    mat = FXMaterial.new
+    mat.diffuse  = FXVec4f.new(0, 0, 0, 0)
+    mat.specular = FXVec4f.new(0, 0, 0, 0)
+    mat.ambient  = FXVec4f.new(0, 0, 0, 0)
+    cube.setMaterial(0, mat)
+    mat2 = cube.getMaterial(0)
+    assert_instance_of(FXVec4f, mat2.ambient)
+    assert_instance_of(FXVec4f, mat2.specular)
+    assert_instance_of(FXVec4f, mat2.diffuse)
+  end
+end

data/test/TC_FXMemoryStream.rb

@@ -0,0 +1,97 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXMemoryStream < Test::Unit::TestCase
+
+  DEFAULT_BUFFER_SIZE = 16
+
+  private
+  
+  def assert_closed(stream)
+    stream.open(FXStreamSave, nil) == false
+  end
+
+  public
+
+  def test_open_streamload_nil_data
+    s = FXMemoryStream.new
+    assert(s.open(FXStreamLoad, nil))
+    assert_equal(DEFAULT_BUFFER_SIZE, s.space)
+    s.close
+  end
+
+  def test_open_streamsave_nil_data
+    s = FXMemoryStream.new
+    assert(s.open(FXStreamSave, nil))
+    assert_equal(DEFAULT_BUFFER_SIZE, s.space)
+    s.close
+  end
+
+  def test_open_streamload_unknown_size
+  	s = FXMemoryStream.new
+  	assert(s.open(FXStreamLoad, "foo"))
+  	s.close
+	end
+
+	def test_open_streamsave_unknown_size
+		s = FXMemoryStream.new
+		assert(s.open(FXStreamSave, "foo"))
+		s.close
+	end
+
+  def test_open_s_load_nil_buffer
+    s = FXMemoryStream.open(FXStreamLoad, nil)
+    assert_equal(DEFAULT_BUFFER_SIZE, s.space)
+    s.close
+  end
+
+  def test_open_s_save_nil_buffer
+    s = FXMemoryStream.open(FXStreamSave, nil)
+    assert_equal(DEFAULT_BUFFER_SIZE, s.space)
+    s.close
+  end
+
+  def test_open_s_load_unknown_buffer_size
+    s = FXMemoryStream.open(FXStreamLoad, "foo")
+    assert_equal(3, s.space)
+    s.close
+  end
+
+  def test_open_s_save_unknown_buffer_size
+    s = FXMemoryStream.open(FXStreamSave, "foo")
+    assert_equal(3, s.space)
+    s.close
+  end
+
+  def test_open_s_with_block
+    stream = nil
+    FXMemoryStream.open(FXStreamLoad, "foo") do |s|
+      stream = s
+    end
+    assert_closed(stream)
+  end
+
+  def test_setSpace
+    FXMemoryStream.open(FXStreamSave, nil) do |stream|
+      stream.space = 5000
+      assert_equal(5000, stream.space)
+    end
+  end
+
+  def test_takeBuffer_empty
+    FXMemoryStream.open(FXStreamSave, nil) do |stream|
+      buffer = stream.takeBuffer
+      assert_equal("\0" * 16, buffer)
+    end
+  end
+
+  def test_giveBuffer
+    FXMemoryStream.open(FXStreamLoad, nil) do |stream|
+      assert_equal(DEFAULT_BUFFER_SIZE, stream.space) 
+      stream.giveBuffer("foo")
+      assert_equal(3, stream.space)
+    end
+  end
+end

data/test/TC_FXMenuCheck.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXMenuCheck < TestCase
+  def setup
+    super(self.class.name)
+    @menuCheck = FXMenuCheck.new(mainWindow, "menuCheck")
+  end
+  
+  def test_setCheck_TRUE
+    @menuCheck.check = Fox::TRUE
+    assert_equal(true, @menuCheck.check)
+    assert_equal(Fox::TRUE, @menuCheck.checkState)
+    assert(@menuCheck.checked?)
+    assert(!@menuCheck.unchecked?)
+    assert(!@menuCheck.maybe?)
+  end
+  
+  def test_setCheck_FALSE
+    @menuCheck.check = Fox::FALSE
+    assert_equal(false, @menuCheck.check)
+    assert_equal(Fox::FALSE, @menuCheck.checkState)
+    assert(!@menuCheck.checked?)
+    assert(@menuCheck.unchecked?)
+    assert(!@menuCheck.maybe?)
+  end
+  
+  def test_setCheck_MAYBE
+    @menuCheck.check = Fox::MAYBE
+    assert_equal(true, @menuCheck.check) # this is not a typo!
+    assert_equal(Fox::MAYBE, @menuCheck.checkState)
+    assert(!@menuCheck.checked?)
+    assert(!@menuCheck.unchecked?)
+    assert(@menuCheck.maybe?)
+  end
+  
+  def test_setCheck_true
+    @menuCheck.check = true
+    assert_equal(true, @menuCheck.check)
+    assert_equal(Fox::TRUE, @menuCheck.checkState)
+    assert(@menuCheck.checked?)
+    assert(!@menuCheck.unchecked?)
+    assert(!@menuCheck.maybe?)
+  end
+  
+  def test_setCheck_false
+    @menuCheck.check = false
+    assert_equal(false, @menuCheck.check)
+    assert_equal(Fox::FALSE, @menuCheck.checkState)
+    assert(!@menuCheck.checked?)
+    assert(@menuCheck.unchecked?)
+    assert(!@menuCheck.maybe?)
+  end
+end

data/test/TC_FXMenuCommand.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXMenuCommand < TestCase
+  def setup
+    super(self.class.name)
+    @menuCommand = FXMenuCommand.new(mainWindow, "menuCommand")
+  end
+end

data/test/TC_FXMenuRadio.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXMenuRadio < TestCase
+  def setup
+    super(self.class.name)
+    @menuRadio = FXMenuRadio.new(mainWindow, "menuRadio")
+  end
+  
+  def test_setCheck_TRUE
+    @menuRadio.check = Fox::TRUE
+    assert_equal(true, @menuRadio.check)
+    assert_equal(Fox::TRUE, @menuRadio.checkState)
+    assert(@menuRadio.checked?)
+    assert(!@menuRadio.unchecked?)
+    assert(!@menuRadio.maybe?)
+  end
+  
+  def test_setCheck_FALSE
+    @menuRadio.check = Fox::FALSE
+    assert_equal(false, @menuRadio.check)
+    assert_equal(Fox::FALSE, @menuRadio.checkState)
+    assert(!@menuRadio.checked?)
+    assert(@menuRadio.unchecked?)
+    assert(!@menuRadio.maybe?)
+  end
+  
+  def test_setCheck_MAYBE
+    @menuRadio.check = Fox::MAYBE
+    assert_equal(true, @menuRadio.check) # this is not a typo!
+    assert_equal(Fox::MAYBE, @menuRadio.checkState)
+    assert(!@menuRadio.checked?)
+    assert(!@menuRadio.unchecked?)
+    assert(@menuRadio.maybe?)
+  end
+  
+  def test_setCheck_true
+    @menuRadio.check = true
+    assert_equal(true, @menuRadio.check)
+    assert_equal(Fox::TRUE, @menuRadio.checkState)
+    assert(@menuRadio.checked?)
+    assert(!@menuRadio.unchecked?)
+    assert(!@menuRadio.maybe?)
+  end
+  
+  def test_setCheck_false
+    @menuRadio.check = false
+    assert_equal(false, @menuRadio.check)
+    assert_equal(Fox::FALSE, @menuRadio.checkState)
+    assert(!@menuRadio.checked?)
+    assert(@menuRadio.unchecked?)
+    assert(!@menuRadio.maybe?)
+  end
+end

data/test/TC_FXMessageBox.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXMessageBox < TestCase
+  def setup
+    super(self.class.name)
+  end
+  
+  def test_construct_with_save_cancel_dontsave
+    assert_nothing_raised(RangeError) do
+      FXMessageBox.new(mainWindow, "Save?", "Save?", :opts => MBOX_SAVE_CANCEL_DONTSAVE)
+    end
+  end
+  
+  def test_mbox_clicked_dontsave_defined
+    assert(Fox.const_defined?(:MBOX_CLICKED_DONTSAVE))
+  end
+  
+  def test_mbox_clicked_dontsave_equal_to_mbox_clicked_no
+    assert_equal(MBOX_CLICKED_NO, MBOX_CLICKED_DONTSAVE)
+  end
+end

data/test/TC_FXPoint.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXPoint < Test::Unit::TestCase
+  def setup
+    @point1 = FXPoint.new
+    @point2 = FXPoint.new(300, 200)
+    @point3 = FXPoint.new(FXSize.new(300, 200))
+  end
+
+  def test_copy
+    assert_equal(@point1, FXPoint.new(@point1))
+    assert_equal(@point2, FXPoint.new(@point2))
+  end
+
+  # The assertEqual() method will test the implementation of
+  # FXPoint's '==' method, which is the point of this test
+  def test_equals
+    assert_equal(@point2, @point3)
+  
+    samePoint1 = FXPoint.new
+    samePoint1.x = @point1.x
+    samePoint1.y = @point1.y
+    assert_equal(@point1, samePoint1)
+    assert_equal(samePoint1, @point1)
+
+    samePoint2 = FXPoint.new(300, 200)
+    assert_equal(@point2, samePoint2)
+    assert_equal(samePoint2, @point2)
+  end
+
+  def test_uminus
+    point1 = -(@point1)
+    assert(point1.x == -(@point1.x) && point1.y == -(@point1.y))
+    point2 = -(@point2)
+    assert(point2.x == -(@point2.x) && point2.y == -(@point2.y))
+  end
+
+  def test_add
+    assert(FXPoint.new(1, 2) + FXPoint.new(3, 4) == FXPoint.new(4, 6))
+  end
+
+  def test_sub
+    assert(FXPoint.new(4, 6) - FXPoint.new(3, 4) == FXPoint.new(1, 2))
+  end
+
+  def test_mul
+    assert(FXPoint.new(1, 2)*3 == FXPoint.new(3, 6))
+  end
+
+  def test_div
+    assert(FXPoint.new(3, 6)/3 == FXPoint.new(1, 2))
+  end
+end

data/test/TC_FXQuatf.rb

@@ -0,0 +1,93 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXQuatf < Test::Unit::TestCase
+  def setup
+    @quat = FXQuatf.new
+  end
+
+  def test_default_constructor
+    q = FXQuatf.new
+  end
+
+  def test_construct_from_axis_and_angle
+    axis = FXVec3f.new(1.0, 1.0, 1.0)
+    q = FXQuatf.new(axis)
+    q = FXQuatf.new(axis, 0.0)
+  end
+
+  def test_construct_from_components
+    x, y, z, w = 1.0, 1.0, 1.0, 1.0
+    q = FXQuatf.new(x, y, z, w)
+  end
+
+  def test_construct_from_roll_pitch_yaw
+    roll, pitch, yaw = 45.0, 45.0, 45.0
+    q = FXQuatf.new(roll, pitch, yaw)
+  end
+
+  def test_adjust!
+    adjusted = @quat.adjust!
+    assert_same(@quat, adjusted)
+  end
+
+  def test_setRollPitchYaw
+    roll, pitch, yaw = 0.0, 0.0, 0.0
+    @quat.setRollPitchYaw(roll, pitch, yaw)
+  end
+
+  def test_getRollPitchYaw
+    rpy = @quat.getRollPitchYaw()
+    assert_instance_of(Array, rpy)
+    assert_equal(3, rpy.length)
+  end
+
+  def test_exp
+    expQuat = @quat.exp
+    assert_instance_of(FXQuatf, expQuat)
+  end
+
+  def test_log
+    logQuat = @quat.log
+    assert_instance_of(FXQuatf, logQuat)
+  end
+
+  def test_invert
+    invertQuat = @quat.invert
+    assert_instance_of(FXQuatf, invertQuat)
+  end
+
+  def test_conj
+    conjQuat = @quat.conj
+    assert_instance_of(FXQuatf, conjQuat)
+  end
+
+  def test_multiplication_result_is_another_quat
+    q1 = FXQuatf.new(1, 2, 3, 4)
+    q2 = FXQuatf.new(1, 2, 3, 4)
+    product = q1*q2
+    assert_instance_of(FXQuatf, product)
+  end
+
+  def test_multiplication_is_commutative
+    q1 = FXQuatf.new(1, 2, 3, 4)
+    q2 = FXQuatf.new(1, 2, 3, 4)
+    assert_equal(q1*q2, q2*q1)
+  end
+
+  def test_arc
+    a = FXVec3f.new(0.0, 0.0, 0.0)
+    b = FXVec3f.new(0.0, 0.0, 0.0)
+    q = FXQuatf.arc(a, b)
+    assert_instance_of(FXQuatf, q)
+  end
+
+  def test_lerp
+    u = FXQuatf.new
+    v = FXQuatf.new
+    q = FXQuatf.lerp(u, v, 5.0)
+    assert_instance_of(FXQuatf, q)
+  end
+end