fxruby 1.6.15-x86-mswin32-60

data/tests/TC_FXTopWindow.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXTopWindow < Test::Unit::TestCase
+  def setup
+    if FXApp.instance.nil?
+      @app = FXApp.new('TC_FXTopWindow', 'FXRuby')
+      @app.init([])
+    else
+      @app = FXApp.instance
+    end
+    @mainWin = FXMainWindow.new(@app, 'TC_FXButton')
+  end
+  
+  def test_new
+    # Free-floating
+    top1 = FXTopWindow.new(@app, "top1", nil, nil, DECOR_ALL, 0, 0, 0, 0,
+      DEFAULT_PAD, DEFAULT_PAD, DEFAULT_PAD, DEFAULT_PAD,
+      DEFAULT_SPACING, DEFAULT_SPACING)
+    assert_equal("top1", top1.title)
+      
+    # Owned
+    top2 = FXTopWindow.new(@mainWin, "top2", nil, nil, DECOR_ALL, 0, 0, 0, 0,
+      DEFAULT_PAD, DEFAULT_PAD, DEFAULT_PAD, DEFAULT_PAD,
+      DEFAULT_SPACING, DEFAULT_SPACING)
+    assert_same(@mainWin, top2.owner)
+    assert_equal("top2", top2.title)
+  end
+end

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