fxruby 1.6.14-universal-darwin-9

data/tests/TC_FXSegment.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXSegment < Test::Unit::TestCase
+  def test_new
+    aSeg = FXSegment.new
+    assert_equal(0, aSeg.x1)
+    assert_equal(0, aSeg.y1)
+    assert_equal(0, aSeg.x2)
+    assert_equal(0, aSeg.y2)
+  end
+  def test_new_with_values
+    aSeg = FXSegment.new(1, 2, 3, 4)
+    assert_equal(1, aSeg.x1)
+    assert_equal(2, aSeg.y1)
+    assert_equal(3, aSeg.x2)
+    assert_equal(4, aSeg.y2)
+  end
+end
+

data/tests/TC_FXSettings.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'fox16'
+require 'testcase'
+
+include Fox
+
+class TC_FXSettings < TestCase
+
+  def setup
+    super(self.class.name)
+  end
+  
+  def test_each_section_empty_settings
+    empty = FXSettings.new
+    num_sections = 0
+    empty.each_section do |sect|
+      num_sections = num_sections + 1
+    end
+    assert_equal(0, num_sections)
+  end
+  
+  def test_each_section
+    settings = FXSettings.new
+    settings.writeStringEntry('sect1', 'key1', 'value1')
+    settings.writeStringEntry('sect2', 'key2', 'value2')
+    keys = []
+    settings.each_section do |sect|
+      sect.each_key do |key|
+        keys << key
+      end
+    end
+    assert_equal(['key1', 'key2'], keys.sort)
+  end
+end

data/tests/TC_FXShell.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXShell < Test::Unit::TestCase
+  def setup
+    if FXApp.instance.nil?
+      @app = FXApp.new('TC_FXShell', 'FXRuby')
+      @app.init([])
+    else
+      @app = FXApp.instance
+    end
+    @mainWin = FXMainWindow.new(@app, 'TC_FXShell')
+  end
+  
+  def test_new
+    # Free-floating
+    shell1 = FXShell.new(@app, 0, 0, 0, 0, 0)
+      
+    # Owned
+    shell2 = FXShell.new(@mainWin, 0, 0, 0, 0, 0)
+    assert_same(@mainWin, shell2.owner)
+  end
+end

data/tests/TC_FXSize.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXSize < Test::Unit::TestCase
+  def setup
+    @size1 = FXSize.new
+    @size2 = FXSize.new(300, 200)
+  end
+
+  def test_copy
+    assert_equal(@size1, FXSize.new(@size1))
+    assert_equal(@size2, FXSize.new(@size2))
+  end
+
+  def test_equals
+    @size1.w = 250
+    @size1.h = 475
+    sameSize1 = FXSize.new
+    sameSize1.w = 250
+    sameSize1.h = 475
+    assert_equal(@size1, sameSize1)
+    assert_equal(sameSize1, @size1)
+
+    sameSize2 = FXSize.new(300, 200)
+    assert_equal(@size2, sameSize2)
+    assert_equal(sameSize2, @size2)
+  end
+
+  def test_uminus
+    size1 = -(@size1)
+    assert(size1.w == -(@size1.w) && size1.h == -(@size1.h))
+    size2 = -(@size2)
+    assert(size2.w == -(@size2.w) && size2.h == -(@size2.h))
+  end
+
+  def test_add
+    assert_equal(FXSize.new(1, 2) + FXSize.new(3, 4), FXSize.new(4, 6))
+  end
+
+  def test_sub
+    assert_equal(FXSize.new(4, 6) - FXSize.new(3, 4), FXSize.new(1, 2))
+  end
+
+  def test_mul
+    assert_equal(FXSize.new(1, 2)*3, FXSize.new(3, 6))
+  end
+
+  def test_div
+    assert_equal(FXSize.new(3, 6)/3, FXSize.new(1, 2))
+  end
+end

data/tests/TC_FXStream.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'fox16'
+require 'testcase'
+
+include Fox
+
+class TC_FXStream < TestCase
+  def setup
+    super(self.class.name)
+  end
+end

data/tests/TC_FXTable.rb

@@ -0,0 +1,368 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class OverrideError < Exception
+end
+
+class CustomTable < FXTable
+  def setColumnWidth(col, cwidth)
+    raise OverrideError
+  end
+
+  def setRowHeight(row, rheight)
+    raise OverrideError
+  end
+
+  def setColumnX(colEdge, x)
+    raise OverrideError
+  end
+
+  def setRowY(rowEdge, y)
+    raise OverrideError
+  end
+end
+
+class TC_FXTable < TestCase
+
+private
+
+  def populateTable
+    @table.each_row do |row|
+      row.each { |item| item.text = "foo" }
+    end
+  end
+
+  def clearEdges(extending=false)
+    item = nil
+    nr = @table.numRows
+    nc = @table.numColumns
+    
+    (1..nc-2).each { |c|
+      item = @table.getItem(nr-1, c)
+        item.button = false
+        item.justify = FXTableItem::RIGHT
+    }
+    
+    unless extending
+      (1..nr-2).each { |r|
+        item = @table.getItem(r, nc-1)
+          item.button = false
+      }
+      if nr > 0 and nc > 0
+        item = @table.getItem(nr-1, nc-1)
+          item.button = false
+          item.text = ""
+      end
+    end
+  end
+
+  def loadLogChunk(num_rows)
+    if @logsource
+      extending = true
+    else
+      extending = false
+      @logsource = nil
+      @header_row = ["foo"]*10
+      @data_lines = []
+    end
+
+    100.times { @data_lines << ["1"]*10 }
+
+    item = nil
+
+    clearEdges(extending)
+
+    old_nr = @table.numRows
+    old_nc = @table.numColumns
+
+    # resize the table
+    nr = @data_lines.size + 2
+    nc = @header_row.size + 2
+    @table.setTableSize(nr, nc)
+
+    @table.leadingRows = 1
+    @table.leadingColumns = 1
+    @table.trailingRows = 1
+    @table.trailingColumns = 1
+
+    # Initialize first & last fixed rows
+    (1..nc-2).each { |c|
+      unless extending
+        @table.setItemText(0, c, @header_row[c-1])
+        item = @table.getItem(0, c)
+          item.button = true
+      end
+      @table.setItemText(nr-1, c, @header_row[c-1])
+      item = @table.getItem(nr-1, c)
+        item.button = true
+    }
+
+    # Initialize first & last fixed columns
+    start_r = extending ? old_nr-1 : 1
+    (start_r..nr-2).each { |r|
+      @table.setItemText(r,  0, "#{r}")
+      @table.setItemText(r, nc-1, "#{r}")
+      @table.getItem(r, 0).setButton(true)
+      @table.getItem(r, nc-1).setButton(true)
+    }
+
+    # The corners are just buttons
+    @table.setItemText(0, 0, "")
+    @table.getItem(0, 0).setButton(true)
+    @table.setItemText(0, nc-1, "")
+    @table.getItem(0, nc-1).setButton(true)
+    @table.setItemText(nr-1, 0, "")
+    @table.getItem(nr-1, 0).setButton(true)
+    @table.setItemText(nr-1, nc-1, "")
+    item = @table.getItem(nr-1, nc-1)
+      item.button = true
+      if false
+        # disable the button
+        @more_pos = nil
+      else
+        remaining = 100
+        if remaining > 1024
+          item.text = "%5.1fM MORE" % (remaining/1024)
+        else
+          item.text = "%5.1fK MORE" % remaining
+        end
+        @more_pos = FXTablePos.new
+        @more_pos.row = nr-1; @more_pos.col = nc-1
+      end
+    @table.setItemText(0, nc-1, "")
+
+    # Initialize scrollable part of table
+    entry = nil
+    (start_r..nr-2).each { |r|
+      (1..nc-2).each { |c|
+        entry = @data_lines[r-1][c-1]
+        case entry
+        when /\A(.*\.)(.*)\z/
+          entry = sprintf("%10.5f", entry.to_f).
+            sub(/\.(\d*?)(0*)$/) { ".#{$1}#{$2.gsub("0", " ")}" }
+        when /\d+/
+          entry << " " * 6
+        end
+        @table.setItemText(r, c, entry)
+      }
+    }
+  end
+
+  # Load the named log file
+  def loadLog filename = @file_names
+    @file_names = filename
+    @logsource = nil
+    clearEdges
+    @table.setTableSize(0, 0)
+    loadLogChunk(100)
+  end
+
+public
+  
+  def setup
+    super(self.class.name)
+    @table = FXTable.new(mainWindow)
+    @customTable = CustomTable.new(mainWindow)
+    populateTable
+  end
+
+=begin
+  def test_setTableSize
+    100.times { loadLog } # this should be enough to do it
+  end
+=end
+  
+  def test_getCellColor
+    assert_nothing_raised {
+      @table.getCellColor(0, 0)
+    }
+    assert_nothing_raised {
+      @table.getCellColor(0, 1)
+    }
+    assert_nothing_raised {
+      @table.getCellColor(1, 0)
+    }
+    assert_nothing_raised {
+      @table.getCellColor(1, 1)
+    }
+
+    @table.setTableSize(5, 5)
+    assert_raises(IndexError) {
+      @table.getCellColor(-1, 0)
+    }
+    assert_raises(IndexError) {
+      @table.getCellColor(2, 0)
+    }
+    assert_raises(IndexError) {
+      @table.getCellColor(0, -1)
+    }
+    assert_raises(IndexError) {
+      @table.getCellColor(0, 2)
+    }
+  end
+
+  def test_setCellColor
+    assert_nothing_raised {
+      @table.setCellColor(0, 0, FXRGB(0, 0, 0))
+    }
+    assert_nothing_raised {
+      @table.setCellColor(0, 1, FXRGB(0, 0, 0))
+    }
+    assert_nothing_raised {
+      @table.setCellColor(1, 0, FXRGB(0, 0, 0))
+    }
+    assert_nothing_raised {
+      @table.setCellColor(1, 1, FXRGB(0, 0, 0))
+    }
+
+    @table.setTableSize(5, 5)
+    assert_raises(IndexError) {
+      @table.setCellColor(-1, 0, FXRGB(0, 0, 0))
+    }
+    assert_raises(IndexError) {
+      @table.setCellColor(2, 0, FXRGB(0, 0, 0))
+    }
+    assert_raises(IndexError) {
+      @table.setCellColor(0, -1, FXRGB(0, 0, 0))
+    }
+    assert_raises(IndexError) {
+      @table.setCellColor(0, 2, FXRGB(0, 0, 0))
+    }
+  end
+  
+  def test_updateRange
+    @table.setTableSize(5, 5)
+    assert_nothing_raised {
+      @table.updateRange(0, 4, 0, 4)
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(-1, 0, 0, 0) # startRow < 0
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(0, 5, 0, 0) # endRow >= numRows
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(0, 0, -1, 0) # startCol < 0
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(0, 0, 0, 5) # endCol >= numColumns
+    }
+  end
+  
+  def test_insertRows
+    @table.setTableSize(5, 5)
+    assert_nothing_raised {
+      @table.insertRows(0)
+    }
+    assert_nothing_raised {
+      @table.insertRows(@table.numRows)
+    }
+    assert_raises(IndexError) {
+      @table.insertRows(-1) # row < 0
+    }
+    assert_raises(IndexError) {
+      @table.insertRows(@table.numRows+1) # row > numRows
+    }
+  end
+
+  def test_insertColumns
+    @table.setTableSize(5, 5)
+    assert_nothing_raised {
+      @table.insertColumns(0)
+    }
+    assert_nothing_raised {
+      @table.insertColumns(@table.numColumns)
+    }
+    assert_raises(IndexError) {
+      @table.insertColumns(-1) # column < 0
+    }
+    assert_raises(IndexError) {
+      @table.insertColumns(@table.numColumns+1) # column > numColumns
+    }
+  end
+  
+  def test_removeRows
+    @table.setTableSize(8, 5)
+    assert_raises(IndexError) {
+      @table.removeRows(-1)
+    }
+    assert_nothing_raised {
+      @table.removeRows(0)
+    }
+    assert_nothing_raised {
+      @table.removeRows(@table.numRows-1)
+    }
+    assert_raises(IndexError) {
+      @table.removeRows(@table.numRows)
+    }
+  end
+  
+  def test_removeColumns
+    @table.setTableSize(5, 8)
+    assert_raises(IndexError) {
+      @table.removeColumns(-1)
+    }
+    assert_nothing_raised {
+      @table.removeColumns(0)
+    }
+    assert_nothing_raised {
+      @table.removeColumns(@table.numColumns-1)
+    }
+    assert_raises(IndexError) {
+      @table.removeColumns(@table.numColumns)
+    }
+  end
+
+  def test_getColumnX
+    @table.setTableSize(5, 5)
+    assert_raises(IndexError) {
+      @table.getColumnX(-1)
+    }
+    assert_nothing_raised {
+      @table.getColumnX(0)
+    }
+    assert_nothing_raised {
+      @table.getColumnX(4)
+    }
+    assert_raises(IndexError) {
+      @table.getColumnX(5)
+    }
+  end
+  
+  def test_getRowY
+    @table.setTableSize(5, 5)
+    assert_raises(IndexError) {
+      @table.getRowY(-1)
+    }
+    assert_nothing_raised {
+      @table.getRowY(0)
+    }
+    assert_nothing_raised {
+      @table.getRowY(4)
+    }
+    assert_raises(IndexError) {
+      @table.getRowY(5)
+    }
+  end
+
+  def test_extractText
+    @table.setTableSize(2, 2)
+    @table.setItemText(0, 0, "(0, 0)")
+    @table.setItemText(0, 1, "(0, 1)")
+    @table.setItemText(1, 0, "(1, 0)")
+    @table.setItemText(1, 1, "(1, 1)")
+    assert_equal("(0, 0)\t(0, 1)\n(1, 0)\t(1, 1)\n", @table.extractText(0, 1, 0, 1))
+  end
+  
+  def test_overlayText
+    @table.setTableSize(2, 2)
+    @table.overlayText(0, 1, 0, 1, "(0, 0)\t(0, 1)\n(1, 0)\t(1, 1)\n")
+    assert_equal("(0, 0)", @table.getItemText(0, 0))
+    assert_equal("(0, 1)", @table.getItemText(0, 1))
+    assert_equal("(1, 0)", @table.getItemText(1, 0))
+    assert_equal("(1, 1)", @table.getItemText(1, 1))
+  end
+end

data/tests/TC_FXTableItem.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class OverrideError < Exception
+end
+
+class CustomTableItem < FXTableItem
+  def getText
+    raise OverrideError
+  end
+  def getIcon
+    raise OverrideError
+  end
+end
+
+class TC_FXTableItem < TestCase
+  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/tests/TC_FXText.rb

@@ -0,0 +1,96 @@
+require 'test/unit'
+require 'fox16'
+require 'fox16/colors'
+require 'testcase'
+
+include Fox
+
+SAMPLE = "The quick brown fox jumped over the lazy dog"
+
+class TC_FXText < TestCase
+
+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/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