fxruby 1.2.2

data/tests/TC_FXMaterial.rb

@@ -0,0 +1,75 @@
+require 'test/unit'
+
+require 'fox12'
+
+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
+end

data/tests/TC_FXMemoryStream.rb

@@ -0,0 +1,87 @@
+require 'test/unit'
+require 'fox12'
+
+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
+    s1 = FXMemoryStream.new
+    assert(s1.open(FXStreamLoad, nil))
+    assert_equal(DEFAULT_BUFFER_SIZE, s1.space)
+    s1.close
+
+    s2 = FXMemoryStream.new
+    assert(s2.open(FXStreamSave, nil))
+    assert_equal(DEFAULT_BUFFER_SIZE, s2.space)
+    s2.close
+
+    s3 = FXMemoryStream.new
+    assert(s3.open(FXStreamLoad, "foo"))
+    assert_equal(3, s3.space)
+    s3.close
+
+    s4 = FXMemoryStream.new
+    assert(s4.open(FXStreamSave, "foo"))
+    assert_equal(3, s4.space)
+    s4.close
+  end
+
+  def test_open_s
+    s1 = FXMemoryStream.open(FXStreamLoad, nil)
+    assert_equal(DEFAULT_BUFFER_SIZE, s1.space)
+    s1.close
+
+    s2 = FXMemoryStream.open(FXStreamSave, nil)
+    assert_equal(DEFAULT_BUFFER_SIZE, s2.space)
+    s2.close
+
+    s3 = FXMemoryStream.open(FXStreamLoad, "foo")
+    assert_equal(3, s3.space)
+    s3.close
+
+    s4 = FXMemoryStream.open(FXStreamSave, "foo")
+    assert_equal(3, s4.space)
+    s4.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", 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/tests/TC_FXMenuCommand.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'testcase'
+require 'fox12'
+
+include Fox
+
+class TC_FXMenuCommand < TestCase
+  def setup
+    super(self.class.name)
+    @menuCommand = FXMenuCommand.new(mainWindow, "menuCommand")
+  end
+  
+  def test_checked?
+    @menuCommand.check
+    assert(@menuCommand.checked?)
+    @menuCommand.uncheck
+    assert(!@menuCommand.checked?)
+  end
+  
+  def test_radioChecked?
+    @menuCommand.checkRadio
+    assert(@menuCommand.radioChecked?)
+    @menuCommand.uncheckRadio
+    assert(!@menuCommand.radioChecked?)
+  end
+end

data/tests/TC_FXPoint.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+
+require 'fox12'
+
+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/tests/TC_FXQuatf.rb

@@ -0,0 +1,77 @@
+require 'test/unit'
+require 'fox12'
+
+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_setAxisAngle
+  end
+  def test_getAxisAngle
+  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_mul
+    anotherQuat = FXQuatf.new
+    product = @quat*anotherQuat
+    assert_instance_of(FXQuatf, product)
+    assert_equal(product, anotherQuat*@quat)
+  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

data/tests/TC_FXRadioButton.rb

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

data/tests/TC_FXRangef.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+
+require 'fox12'
+
+include Fox
+
+class TC_FXRangef < Test::Unit::TestCase
+
+  WIDTH, HEIGHT, DEPTH = 2, 4, 6
+
+  def setup
+    @range = FXRangef.new(0, WIDTH, 0, HEIGHT, 0, DEPTH)
+  end
+  
+  def test_width
+    assert_equal(@range.width, WIDTH)
+  end
+  def test_height
+    assert_equal(@range.height, HEIGHT)
+  end
+  def test_depth
+    assert_equal(@range.depth, DEPTH)
+  end
+  def test_longest
+    assert_equal([@range.width, @range.height, @range.depth].max, @range.longest)
+  end
+  def test_shortest
+    assert_equal([@range.width, @range.height, @range.depth].min, @range.shortest)
+  end
+  def test_empty?
+  end
+  def test_overlaps?
+  end
+  def test_contains?
+  end
+  def test_include
+  end
+  def test_clipTo
+  end
+  def test_corners
+  end
+  def test_intersects?
+  end
+  def test_center
+  end
+  def test_diagonal
+  end
+end

data/tests/TC_FXRectangle.rb

@@ -0,0 +1,88 @@
+require 'test/unit'
+
+require 'fox12'
+
+include Fox
+
+class TC_FXRectangle < Test::Unit::TestCase
+  def setup
+    @rect1 = FXRectangle.new
+    @rect2 = FXRectangle.new(5, 5, 300, 200)
+    @rect3 = FXRectangle.new(FXPoint.new(5, 5), FXSize.new(300, 200))
+    @rect4 = FXRectangle.new(FXPoint.new(5, 5), FXPoint.new(304, 204))
+  end
+
+  def test_equals
+    r1 = FXRectangle.new
+    r1.x = 10
+    r1.y = 15
+    r1.w = 20
+    r1.h = 25
+    @rect1.x = r1.x
+    @rect1.y = r1.y
+    @rect1.w = r1.w
+    @rect1.h = r1.h
+    assert_equal(@rect1, r1)
+    assert_equal(@rect2, FXRectangle.new(5, 5, 300, 200))
+    assert_equal(@rect3, FXRectangle.new(FXPoint.new(5, 5), FXSize.new(300, 200)))
+    assert_equal(@rect4, FXRectangle.new(FXPoint.new(5, 5), FXPoint.new(304, 204)))
+  end
+
+  def test_contains?
+    assert(@rect2.contains?(100, 100))
+    assert(@rect2.contains?(FXPoint.new(100, 100)))
+    assert(@rect2.contains?(FXRectangle.new(10, 10, 10, 10)))
+  end
+
+  def test_overlaps?
+    assert(@rect2.overlaps?(@rect3))
+    assert(@rect2.overlaps?(FXRectangle.new(200, 2, 400, 50)))
+    assert(!@rect2.overlaps?(FXRectangle.new(2, 2, 2, 2)))
+  end
+
+  def test_move!
+    x = @rect2.x
+    y = @rect2.y
+    result = @rect2.move!(10, 10)
+    assert_same(@rect2, result)
+    assert_equal(@rect2.x, x + 10)
+    assert_equal(@rect2.y, y + 10)
+  end
+
+  def test_grow!
+    result = @rect2.grow!(3)
+    assert_same(@rect2, result)
+    result = @rect3.grow!(3, 3)
+    assert_same(@rect3, result)
+    result = @rect4.grow!(3, 3, 3, 3)
+    assert_same(@rect4, result)
+    assert_equal(@rect2, @rect3)
+    assert_equal(@rect2, @rect4)
+    assert_equal(@rect3, @rect4)
+  end
+
+  def test_shrink!
+    result = @rect2.shrink!(3)
+    assert_same(@rect2, result)
+    result = @rect3.shrink!(3, 3)
+    assert_same(@rect3, result)
+    result = @rect4.shrink!(3, 3, 3, 3)
+    assert_same(@rect4, result)
+    assert_equal(@rect2, @rect3)
+    assert_equal(@rect2, @rect4)
+    assert_equal(@rect3, @rect4)
+  end
+
+  def test_corners
+    assert_equal(FXPoint.new(  5,   5), @rect2.tl)
+    assert_equal(FXPoint.new(304,   5), @rect2.tr)
+    assert_equal(FXPoint.new(  5, 204), @rect2.bl)
+    assert_equal(FXPoint.new(304, 204), @rect2.br)
+  end
+
+  def test_union
+  end
+
+  def test_intersection
+  end
+end