fxrubi 1.6.22.pre1-x86-mingw32

data/test/TC_FXTableItem.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+class OverrideError < Exception
+end
+
+class CustomTableItem < Fox::FXTableItem
+  def getText
+    raise OverrideError
+  end
+  def getIcon
+    raise OverrideError
+  end
+end
+
+class TC_FXTableItem < Fox::TestCase
+  include Fox
+
+  def setup
+    super(self.class.name)
+    @table = FXTable.new(mainWindow)
+    @table.setTableSize(1, 1)
+    @tableItem = FXTableItem.new("item")
+  end
+
+  def test_setStipple
+    @tableItem.stipple = STIPPLE_CROSSDIAG
+  end
+
+  def test_getStipple
+    assert_kind_of(Integer, @tableItem.stipple)
+  end
+
+  def test_overridden_getText
+    @table.setItem(0, 0, CustomTableItem.new(""))
+    assert_raises(OverrideError) {
+      @table.getItemText(0, 0)
+    }
+  end
+
+  def test_overridden_getIcon
+    @table.setItem(0, 0, CustomTableItem.new(""))
+    assert_raises(OverrideError) {
+      @table.getItemIcon(0, 0)
+    }
+  end
+end

data/test/TC_FXText.rb

@@ -0,0 +1,96 @@
+require 'test/unit'
+require 'fox16'
+require 'fox16/colors'
+require 'testcase'
+
+SAMPLE = "The quick brown fox jumped over the lazy dog"
+
+class TC_FXText < Fox::TestCase
+  include Fox
+
+
+private
+
+  def setup_text
+    @text = FXText.new(mainWindow)
+    @text.text = SAMPLE
+  end
+
+  def setup_styled_text
+    @styledText = FXText.new(mainWindow)
+
+    hs1 = FXHiliteStyle.new
+    hs1.normalForeColor = FXColor::Red
+    hs1.normalBackColor = FXColor::Blue
+    hs1.selectForeColor = @styledText.selTextColor
+    hs1.selectBackColor = @styledText.selBackColor
+    hs1.hiliteForeColor = @styledText.hiliteTextColor
+    hs1.hiliteBackColor = @styledText.hiliteBackColor
+    hs1.activeBackColor = @styledText.activeBackColor
+    hs1.style = 0
+
+    hs2 = FXHiliteStyle.new
+    hs2.normalForeColor = FXColor::Blue
+    hs2.normalBackColor = FXColor::Yellow
+    hs2.selectForeColor = @styledText.selTextColor
+    hs2.selectBackColor = @styledText.selBackColor
+    hs2.hiliteForeColor = @styledText.hiliteTextColor
+    hs2.hiliteBackColor = @styledText.hiliteBackColor
+    hs2.activeBackColor = @styledText.activeBackColor
+    hs2.style = FXText::STYLE_UNDERLINE
+
+    @styledText.styled = true
+    @styledText.hiliteStyles = [hs1, hs2]
+    @styledText.text = SAMPLE
+    @styledText.changeStyle(SAMPLE.index("quick"), "quick".length, 1)
+    @styledText.changeStyle(SAMPLE.index("lazy"), "lazy".length, 2)
+  end
+
+public
+
+  def setup
+    super(self.class.name)
+    setup_text
+    setup_styled_text
+  end
+
+  def test_extractStyle
+    assert_nil(@text.extractStyle(0, 5))
+    assert_equal("", @styledText.extractStyle(0, 0))
+    assert_equal("\0"*3, @styledText.extractStyle(0, 3))
+    assert_equal("\1"*"quick".length, @styledText.extractStyle(SAMPLE.index("quick"), "quick".length))
+    assert_equal("\2"*"lazy".length, @styledText.extractStyle(SAMPLE.index("lazy"), "lazy".length))
+  end
+
+  def test_extractText
+    assert_equal("", @text.extractText(0, 0))
+    assert_equal(SAMPLE, @text.extractText(0, SAMPLE.length))
+    assert_equal("brown", @text.extractText(10, 5))
+  end
+
+  def test_getText
+    assert_equal(SAMPLE, @text.text)
+  end
+
+  def test_find_text
+    @text.text = "99 bottles of beer"
+    startIndex, endIndex = @text.findText("bottles")
+    assert_equal([3], startIndex)
+    assert_equal([10], endIndex)
+  end
+
+  def test_find_text_with_startpos
+    @text.text = "I came, I saw, I conquered"
+    startIndex, endIndex = @text.findText("I ", 5)
+    assert_equal([8], startIndex)
+    assert_equal([10], endIndex)
+  end
+
+  def test_find_text_with_groups
+    @text.text = "I came, I saw, I conquered"
+    startIndex, endIndex = @text.findText("I ([a-z]+)(, )?", 0, SEARCH_REGEX)
+    assert_equal([0, 2, 6], startIndex)
+    assert_equal([8, 6, 8], endIndex)
+  end
+
+end

data/test/TC_FXTopWindow.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+
+require 'fox16'
+
+class TC_FXTopWindow < Test::Unit::TestCase
+  include Fox
+
+  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/test/TC_FXTreeList.rb

@@ -0,0 +1,100 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+class TC_FXTreeList < Fox::TestCase
+  include Fox
+
+  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/test/TC_FXTreeListBox.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+class TC_FXTreeListBox < Fox::TestCase
+  include Fox
+
+  
+  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/test/TC_FXUndoList.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'fox16'
+require 'fox16/undolist'
+
+class DummyCommand < Fox::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
+  include Fox
+
+  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/test/TC_FXVec2d.rb

@@ -0,0 +1,142 @@
+require 'test/unit'
+
+require 'fox16'
+
+class TC_FXVec2d < Test::Unit::TestCase
+  include Fox
+
+
+  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