fxruby 1.2.2

data/tests/TC_FXRegion.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+
+require 'fox12'
+
+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 'fox12'
+
+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 'fox12'
+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 'fox12'
+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

data/tests/TC_FXSegment.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'fox12'
+
+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_FXShell.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+
+require 'fox12'
+
+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 'fox12'
+
+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 'fox12'
+require 'testcase'
+
+include Fox
+
+class TC_FXStream < TestCase
+  def setup
+    super(self.class.name)
+  end
+end

data/tests/TC_FXTable.rb

@@ -0,0 +1,468 @@
+require 'test/unit'
+require 'testcase'
+require 'fox12'
+
+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, 0, 0)
+    @customTable = CustomTable.new(mainWindow, 0, 0)
+    populateTable
+  end
+  
+  def test_setTableSize
+    100.times { loadLog } # this should be enough to do it
+  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, 5, 0, 5)
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(-1, 5, 0, 5) # startRow < 0
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(0, 6, 0, 5) # endRow > numRows
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(0, 5, -1, 5) # startCol < 0
+    }
+    assert_raises(IndexError) {
+      @table.updateRange(0, 5, 0, 6) # 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(5)
+    }
+    assert_raises(IndexError) {
+      @table.getColumnX(6)
+    }
+  end
+  
+  def test_setColumnX
+    @table.setTableSize(5, 5)
+    assert_raises(IndexError) {
+      @table.setColumnX(-1, 0)
+    }
+    assert_nothing_raised {
+      @table.setColumnX(0, 0)
+    }
+    assert_nothing_raised {
+      @table.setColumnX(5, 0)
+    }
+    assert_raises(IndexError) {
+      @table.setColumnX(6, 0)
+    }
+  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(5)
+    }
+    assert_raises(IndexError) {
+      @table.getRowY(6)
+    }
+  end
+  
+  def test_setRowY
+    @table.setTableSize(5, 5)
+    assert_raises(IndexError) {
+      @table.setRowY(-1, 0)
+    }
+    assert_nothing_raised {
+      @table.setRowY(0, 0)
+    }
+    assert_nothing_raised {
+      @table.setRowY(5, 0)
+    }
+    assert_raises(IndexError) {
+      @table.setRowY(6, 0)
+    }
+  end
+  
+  def test_setLeadingRows
+    @table.setTableSize(5, 5)
+    @table.trailingRows = 2
+    assert_raises(IndexError) {
+      @table.leadingRows = -1
+    }
+    assert_nothing_raised {
+      @table.leadingRows = 0
+    }
+    assert_nothing_raised {
+      @table.leadingRows = @table.numRows - @table.trailingRows
+    }
+    assert_raises(IndexError) {
+      @table.leadingRows = @table.numRows - @table.trailingRows + 1
+    }
+  end
+  
+  def test_setLeadingCols
+    @table.setTableSize(5, 5)
+    @table.trailingColumns = 2
+    assert_raises(IndexError) {
+      @table.leadingColumns = -1
+    }
+    assert_nothing_raised {
+      @table.leadingColumns = 0
+    }
+    assert_nothing_raised {
+      @table.leadingColumns = @table.numColumns - @table.trailingColumns
+    }
+    assert_raises(IndexError) {
+      @table.leadingColumns = @table.numColumns - @table.trailingColumns + 1
+    }
+  end
+  
+  def test_setTrailingRows
+    @table.setTableSize(5, 5)
+    @table.leadingRows = 2
+    assert_raises(IndexError) {
+      @table.trailingRows = -1
+    }
+    assert_nothing_raised {
+      @table.trailingRows = 0
+    }
+    assert_nothing_raised {
+      @table.trailingRows = @table.numRows - @table.leadingRows
+    }
+    assert_raises(IndexError) {
+      @table.trailingRows = @table.numRows - @table.leadingRows + 1
+    }
+  end
+  
+  def test_setTrailingCols
+    @table.setTableSize(5, 5)
+    @table.leadingColumns = 2
+    assert_raises(IndexError) {
+      @table.trailingColumns = -1
+    }
+    assert_nothing_raised {
+      @table.trailingColumns = 0
+    }
+    assert_nothing_raised {
+      @table.trailingColumns = @table.numColumns - @table.leadingColumns
+    }
+    assert_raises(IndexError) {
+      @table.trailingColumns = @table.numColumns - @table.leadingColumns + 1
+    }
+  end
+
+  def test_overridden_setColumnWidth
+    # What can we do to simulate a call to setColumnWidth?
+  end
+
+  def test_overridden_setRowHeight
+    # What can we do to simulate a call to setRowHeight?
+  end
+
+  def test_overridden_setColumnX
+#   assert_raises(OverrideError) {
+#     @customTable.handle(nil, FXSEL(SEL_MOTION, 0), event)
+#   }
+  end
+
+  def test_overridden_setRowY
+#   assert_raises(OverrideError) {
+#     @customTable.handle(nil, FXSEL(SEL_MOTION, 0), event)
+#   }
+  end
+end