fxruby 1.6.14-universal-darwin-9

data/tests/TC_FXTreeList.rb

@@ -0,0 +1,100 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXTreeList < TestCase
+  def setup
+    super(self.class.name)
+    @treeList = FXTreeList.new(mainWindow, nil, 0,
+      (TREELIST_BROWSESELECT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|
+       TREELIST_ROOT_BOXES|LAYOUT_FILL_X|LAYOUT_FILL_Y))
+  end
+  
+  def test_firstItem
+    assert_nil(@treeList.firstItem)
+    item = @treeList.prependItem(nil, "first")
+    assert_same(item, @treeList.firstItem)
+  end
+
+  def test_lastItem
+    assert_nil(@treeList.lastItem)
+    item = @treeList.prependItem(nil, "first")
+    assert_same(item, @treeList.lastItem)
+  end
+
+  def test_reparentItem
+    rootItem = @treeList.prependItem(nil, "Root Item")
+    childItem = @treeList.prependItem(@treeList.firstItem, "Child Item")
+    @treeList.reparentItem(childItem, nil)
+    assert_same(rootItem, @treeList.firstItem)
+    assert_same(childItem, @treeList.lastItem)
+  end
+
+  def test_moveItemBefore
+    first  = @treeList.appendItem(nil, "first")
+    second = @treeList.appendItem(nil, "second")
+    assert_same(second, first.next)
+    assert_same(first,  second.prev)
+    assert_same(second, @treeList.moveItemBefore(first, second))
+    assert_same(second, first.prev)
+    assert_same(first,  second.next)
+  end
+
+  def test_moveItemAfter
+    first  = @treeList.appendItem(nil, "first")
+    second = @treeList.appendItem(nil, "second")
+    assert_same(second, first.next)
+    assert_same(first,  second.prev)
+    assert_same(first, @treeList.moveItemAfter(second, first))
+    assert_same(second, first.prev)
+    assert_same(first,  second.next)
+  end
+
+  def test_sortRootItems
+    @treeList.appendItem(nil, "B")
+    @treeList.appendItem(nil, "A")
+    @treeList.appendItem(nil, "C")
+    @treeList.sortRootItems
+    assert_equal("A", @treeList.firstItem.text)
+    assert_equal("B", @treeList.firstItem.next.text)
+    assert_equal("C", @treeList.lastItem.text)
+  end
+
+  def test_SEL_INSERTED
+    anItem = nil
+    @treeList.connect(SEL_INSERTED) { |sender, sel, ptr|
+      anItem = ptr
+    }
+    theItem = @treeList.appendItem(nil, "", nil, nil, nil, true)
+    assert_same(theItem, anItem)
+  end
+  
+  def test_SEL_DELETED
+    theItem = @treeList.appendItem(nil, "")
+    anItem = nil
+    @treeList.connect(SEL_DELETED) { |sender, sel, ptr|
+      anItem = ptr
+    }
+    @treeList.removeItem(theItem, true)
+    assert_same(theItem, anItem)
+  end
+
+  def test_each_for_empty_list
+    count = 0
+    @treeList.each { |item| count += 1 }
+    assert_equal(0, count, "count for empty list should be zero")
+  end
+  
+  def test_each
+    @treeList.appendItem(nil, "1")
+    @treeList.appendItem(nil, "2")
+    @treeList.appendItem(nil, "3")
+    @treeList.appendItem(nil, "4")
+    count = 0
+    @treeList.each { |item| count += 1 }
+    assert_equal(4, count, "count didn't match expected number of items")
+  end
+  
+end

data/tests/TC_FXTreeListBox.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXTreeListBox < TestCase
+  
+  def setup
+    super(self.class.name)
+    @treeListBox = FXTreeListBox.new(mainWindow)
+  end
+
+  def test_sortRootItems
+    @treeListBox.appendItem(nil, "B")
+    @treeListBox.appendItem(nil, "A")
+    @treeListBox.appendItem(nil, "C")
+    @treeListBox.sortRootItems
+    assert_equal("A", @treeListBox.firstItem.text)
+    assert_equal("B", @treeListBox.firstItem.next.text)
+    assert_equal("C", @treeListBox.lastItem.text)
+  end
+
+  def test_each_for_empty_list
+    count = 0
+    @treeListBox.each { |item| count += 1 }
+    assert_equal(0, count, "count for empty list should be zero")
+  end
+  
+  def test_each
+    @treeListBox.appendItem(nil, "1")
+    @treeListBox.appendItem(nil, "2")
+    @treeListBox.appendItem(nil, "3")
+    @treeListBox.appendItem(nil, "4")
+    count = 0
+    @treeListBox.each { |item| count += 1 }
+    assert_equal(4, count, "count didn't match expected number of items")
+  end
+  
+end
+

data/tests/TC_FXUndoList.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'fox16'
+require 'fox16/undolist'
+
+include Fox
+
+class DummyCommand < FXCommand
+  def undo ; end
+  def redo ; end
+  def undoName
+    "My Undo Name"
+  end
+  def redoName
+    "My Redo Name"
+  end
+end
+
+class TC_FXUndoList < Test::Unit::TestCase
+  def test_cut_with_nil_marker
+    undoList = FXUndoList.new
+    assert_nothing_raised {
+      undoList.cut
+    }
+  end
+
+  def test_undoName
+    undoList = FXUndoList.new
+    assert_nil(undoList.undoName)
+    c = DummyCommand.new
+    undoList.add(c)
+    assert_equal(c.undoName, undoList.undoName)
+  end
+
+  def test_redoName
+    undoList = FXUndoList.new
+    assert_nil(undoList.redoName)
+    c = DummyCommand.new
+    undoList.add(c)
+    undoList.undo
+    assert_equal(c.redoName, undoList.redoName)
+  end
+end
+

data/tests/TC_FXVec2d.rb

@@ -0,0 +1,142 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXVec2d < Test::Unit::TestCase
+
+  def test_default_constructor
+    FXVec4f.new
+  end
+
+  def test_copy_constructor
+    vec = FXVec2d.new(2.0, 3.0)
+    assert_equal(vec, FXVec2d.new(vec)) # also tests the '==' method!
+  end
+
+  def test_construct_from_components
+    vec = FXVec2d.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 = FXVec2d.new(2.0, 3.0)
+    assert_equal(2.0, vec[0])
+    assert_equal(3.0, vec[1])
+  end
+
+  def test_setitem
+    vec = FXVec2d.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 = FXVec2d.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_neg
+    vec = -FXVec2d.new(1.0, 2.0)
+    assert_equal(vec[0], -1.0)
+    assert_equal(vec[1], -2.0)
+  end
+
+  def test_add
+    a = FXVec2d.new(1.0, 2.0)
+    b = FXVec2d.new(2.0, 4.0)
+    c = FXVec2d.new(3.0, 6.0)
+    assert_equal(c, a + b)
+  end
+
+  def test_subtract
+    a = FXVec2d.new(3.0, 6.0)
+    b = FXVec2d.new(2.0, 4.0)
+    c = FXVec2d.new(1.0, 2.0)
+    assert_equal(c, a - b)
+  end
+
+  def test_multiply_by_scalar
+    v1 = FXVec2d.new(3.0,  6.0)
+    v2 = FXVec2d.new(6.0, 12.0)
+    assert_equal(v2, v1*2)
+  end
+
+  def test_dot_product
+    v1 = FXVec2d.new(3.0, 6.0)
+    v2 = FXVec2d.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 = FXVec2d.new(6.0, 12.0)
+    v2 = FXVec2d.new(3.0,  6.0)
+    assert_equal(v2, v1/2)
+      assert_raises(ZeroDivisionError) {
+      v1/0
+    }
+  end
+
+  # As of fox-1.1.28, the length() function for FXVec2d is using the
+  # single-precision version of sqrtf() instead of the double-precision
+  # sqrt() in its calculation. Let this test continue to fail until
+  # that fix is made to FOX.
+  def test_length
+    v = FXVec2d.new(1.0, 1.0)
+    assert_in_delta(Math.sqrt(2), v.length, 1.0e-12) 
+  end
+
+  def test_length2
+    v = FXVec2d.new(1.0, 1.0)
+    assert_equal(2.0, v.length2) 
+  end
+
+  def test_normalize
+    vec = FXVec2d.new(1.0, 1.0).normalize
+    assert_in_delta(1.0/Math.sqrt(2), vec.x, 1.0e-12)
+    assert_in_delta(1.0/Math.sqrt(2), vec.y, 1.0e-12)
+  end
+
+  def test_lo
+    v1 = FXVec2d.new(3.0, 2.0)
+    v2 = FXVec2d.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 = FXVec2d.new(3.0, 2.0)
+    v2 = FXVec2d.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 = FXVec2d.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(FXVec2d.new(1.0, 2.0) == FXVec2d.new(1.0, 2.0))
+  end
+
+end

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