fxruby 1.6.14-universal-darwin-9

data/tests/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/tests/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/tests/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/tests/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/tests/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/tests/TC_FXQuatf.rb

@@ -0,0 +1,77 @@
+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_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 'fox16'
+
+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 'fox16'
+
+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 'fox16'
+
+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

data/tests/TC_FXRegion.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXRegion < Test::Unit::TestCase
+
+  def setup
+    @region = FXRegion.new(5, 5, 10, 10)
+  end
+
+  def test_construct_from_points
+    points = [
+               FXPoint.new(0, 0),
+               FXPoint.new(0, 100),
+               FXPoint.new(100, 100),
+               FXPoint.new(0, 0)
+             ]
+    r1 = FXRegion.new(points, true)
+    r2 = FXRegion.new(points, false)
+    r3 = FXRegion.new(points)
+  end
+
+  def test_copy_constructor
+    assert_equal(@region, FXRegion.new(@region))
+  end
+
+  def test_empty
+    assert(!@region.empty?)
+    empty_region = FXRegion.new(5, 5, 0, 0)
+    assert(empty_region.empty?)
+  end
+
+  def test_containsPoint
+    # Definitely out of bounds
+    assert(!@region.contains?(2, 3))
+
+    # Definitely in bounds    
+    assert(@region.contains?(6, 6))
+
+    # Check corners too
+    assert(@region.contains?(5, 5))
+    assert(@region.contains?(5, 14))
+    assert(@region.contains?(14, 14))
+    assert(@region.contains?(14, 5))
+  end
+
+  def test_containsRectangle
+    assert(@region.contains?(2, 3, 15, 15)) # why doesn't this fail?
+    assert(@region.contains?(5, 5, 10, 10))
+    assert(@region.contains?(6, 6, 5, 5))
+  end
+end

data/tests/TC_FXRegistry.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXRegistry < Test::Unit::TestCase
+  def setup
+    @reg = FXRegistry.new("TC_FXRegistry", "FXRuby")
+  end
+
+  def test_boolEntries
+    assert(@reg.writeBoolEntry("SETTINGS", "trueEntry", true))
+    assert(@reg.writeBoolEntry("SETTINGS", "falseEntry", false))
+
+    assert(@reg.readBoolEntry("SETTINGS", "trueEntry"))
+    assert(@reg.readBoolEntry("SETTINGS", "trueEntry", true))
+    assert(@reg.readBoolEntry("SETTINGS", "trueEntry", false))
+
+    assert(!@reg.readBoolEntry("SETTINGS", "falseEntry"))
+    assert(!@reg.readBoolEntry("SETTINGS", "falseEntry", true))
+    assert(!@reg.readBoolEntry("SETTINGS", "falseEntry", false))
+
+    assert(!@reg.readBoolEntry("SETTINGS", "missingEntry"))
+    assert(!@reg.readBoolEntry("SETTINGS", "missingEntry", false))
+    assert( @reg.readBoolEntry("SETTINGS", "missingEntry", true))
+  end
+end

data/tests/TC_FXScrollArea.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'fox16'
+require 'testcase'
+
+include Fox
+
+class TC_FXScrollArea < TestCase
+  def setup
+    super(self.class.name)
+    @scrollArea = FXScrollArea.new(mainWindow)
+  end
+
+  def test_position_get
+    pos = @scrollArea.position
+    assert_instance_of(Array, pos)
+    assert_equal(2, pos.size)
+    assert_kind_of(Integer, pos[0])
+    assert_kind_of(Integer, pos[1])
+  end
+  
+  def test_setPosition
+    @scrollArea.setPosition(0, 0)
+  end
+
+  def test_position_move_and_resize
+    @scrollArea.position(0, 0, 1, 1)
+  end
+end

data/tests/TC_FXScrollWindow.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'fox16'
+require 'testcase'
+
+include Fox
+
+class TC_FXScrollWindow < TestCase
+  def setup
+    super(self.class.name)
+    @scrollWindow = FXScrollWindow.new(mainWindow)
+  end
+
+  def test_position_get
+    pos = @scrollWindow.position
+    assert_instance_of(Array, pos)
+    assert_equal(2, pos.size)
+    assert_kind_of(Integer, pos[0])
+    assert_kind_of(Integer, pos[1])
+  end
+  
+  def test_setPosition
+    @scrollWindow.setPosition(0, 0)
+  end
+
+  def test_position_move_and_resize
+    @scrollWindow.position(0, 0, 1, 1)
+  end
+end