fxruby 1.6.14-universal-darwin-9

data/tests/TC_FXDC.rb

@@ -0,0 +1,372 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXDC < Test::Unit::TestCase
+  def setup
+    if FXApp.instance.nil?
+      @app = FXApp.new('TC_FXDC', 'FXRuby')
+      @app.init([])
+    else
+      @app = FXApp.instance
+    end
+    @dc = FXDC.new(@app)
+  end
+  
+  def testGetApp
+    app = @dc.app
+    assert(app)
+    assert_kind_of(FXApp, app)
+    assert_same(@app, app)
+  end
+  
+  def testReadPixel
+    x, y = 0, 0
+    pixel = @dc.readPixel(x, y)
+    assert(pixel)
+  end
+  
+  def testDrawPoint
+    @dc.drawPoint(0, 0)
+  end
+  
+  def testDrawPoints
+    p1 = FXPoint.new
+    p2 = FXPoint.new
+    @dc.drawPoints([p1, p2])
+  end
+  
+  def testDrawPointsRel
+    p1 = FXPoint.new
+    p2 = FXPoint.new
+    @dc.drawPointsRel([p1, p2])
+  end
+  
+  def testDrawLine
+    x1, y1, x2, y2 = 0, 0, 5, 5
+    @dc.drawLine(x1, y1, x2, y2)
+  end
+  
+  def testDrawLines
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.drawLines(points)
+  end
+  
+  def testDrawLinesRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.drawLinesRel(points)
+  end
+  
+  def testDrawLineSegments
+    segments = [ FXSegment.new, FXSegment.new ]
+    @dc.drawLineSegments(segments)
+  end
+  
+  def testDrawArc
+    x, y, w, h, ang1, ang2 = 0, 0, 10, 10, 45, 135
+    @dc.drawArc(x, y, w, h, ang1, ang2)
+  end
+  
+  def testDrawArcs
+    arcs = [ FXArc.new, FXArc.new ]
+    @dc.drawArcs(arcs)
+  end
+  
+  def testFillRectangle
+    x, y, w, h = 0, 0, 20, 20
+    @dc.fillRectangle(x, y, w, h)
+  end
+  
+  def testFillRectangles(rectangles)
+    rectangles = [ FXRectangle.new, FXRectangle.new ]
+    @dc.fillRectangles(rectangles)
+  end
+  
+  def testFillArc
+    x, y, w, h, ang1, ang2 = 0, 0, 10, 10, 45, 135
+    @dc.fillArc(x, y, w, h, ang1, ang2)
+  end
+  
+  def testFillArcs
+    arcs = [ FXArc.new, FXArc.new ]
+    @dc.fillArcs(arcs)
+  end
+  
+  def testFillPolygon
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillPolygon(points)
+  end
+  
+  def testFillConcavePolygon
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillConcavePolygon(points)
+  end
+  
+  def testFillComplexPolygon
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillComplexPolygon(points)
+  end
+  
+  def testFillPolygonRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillPolygonRel(points)
+  end
+
+  def testFillConcavePolygonRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillConcavePolygonRel(points)
+  end
+
+  def testFillComplexPolygonRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillComplexPolygonRel(points)
+  end
+  
+  def testDrawHashBox
+    x, y, w, h, b = 0, 0, 20, 20, 2
+    @dc.drawHashBox(x, y, w, h)
+    @dc.drawHashBox(x, y, w, h, b)
+  end
+  
+  def testDrawFocusRectangle
+    x, y, w, h = 0, 0, 5, 5
+    @dc.drawFocusRectangle(x, y, w, h)
+  end
+  
+  def testDrawArea
+    source = FXImage.new(@app)
+    sx, sy, sw, sh = 0, 0, 10, 10
+    dx, dy = 0, 0
+    @dc.drawArea(source, sx, sy, sw, sh, dx, dy)
+  end
+  
+  def testDrawImage
+    image, dx, dy = FXImage.new(@app), 0, 0
+    @dc.drawImage(image, dx, dy)
+  end
+  
+  def testDrawBitmap
+    bitmap, dx, dy = FXBitmap.new(@app), 0, 0
+    @dc.drawBitmap(bitmap, dx, dy)
+  end
+  
+  def testDrawIcon
+    icon, dx, dy = FXIcon.new(@app), 0, 0
+    @dc.drawIcon(icon, dx, dy)
+  end
+  
+  def testDrawIconSunken
+    icon, dx, dy = FXIcon.new(@app), 0, 0
+    @dc.drawIconSunken(icon, dx, dy)
+  end
+  
+  def testDrawIconShaded
+    icon, dx, dy = FXIcon.new(@app), 0, 0
+    @dc.drawIconShaded(icon, dx, dy)
+  end
+  
+  def testDrawText
+    x, y, str = 0, 0, "Hello"
+    @dc.drawText(x, y, str)
+  end
+  
+  def testDrawImageText
+    x, y, str = 0, 0, "Hello"
+    @dc.drawImageText(x, y, str)
+  end
+  
+  def testForeground
+    fg = FXRGB(192, 192, 192)
+    @dc.setForeground(fg)
+    assert_equal(fg, @dc.foreground)
+    assert_equal(fg, @dc.getForeground)
+    @dc.foreground = fg
+    assert_equal(fg, @dc.foreground)
+    assert_equal(fg, @dc.getForeground)
+  end
+
+  def testBackground
+    bg = FXRGB(192, 192, 192)
+    @dc.setBackground(bg)
+    assert_equal(bg, @dc.background)
+    assert_equal(bg, @dc.getBackground)
+    @dc.background = bg
+    assert_equal(bg, @dc.background)
+    assert_equal(bg, @dc.getBackground)
+  end
+  
+  def testDashes
+    dashOffset, dashPattern = 0, [1, 2, 3, 4]
+    @dc.setDashes(dashOffset, dashPattern)
+    assert_equal(dashPattern, @dc.dashPattern)
+    assert_equal(dashPattern, @dc.getDashPattern())
+    assert_equal(dashOffset, @dc.dashOffset)
+    assert_equal(dashOffset, @dc.getDashOffset())
+  end
+  
+  def testLineWidth
+    lineWidth = 2
+    @dc.setLineWidth(lineWidth)
+    assert_equal(lineWidth, @dc.lineWidth)
+    assert_equal(lineWidth, @dc.getLineWidth())
+    @dc.lineWidth = lineWidth
+    assert_equal(lineWidth, @dc.lineWidth)
+    assert_equal(lineWidth, @dc.getLineWidth())
+  end
+
+  def testLineCap
+    for lineCap in [CAP_NOT_LAST, CAP_BUTT, CAP_ROUND, CAP_PROJECTING]
+      @dc.setLineCap(lineCap)
+      assert_equal(lineCap, @dc.lineCap)
+      assert_equal(lineCap, @dc.getLineCap())
+      @dc.lineCap = lineCap
+      assert_equal(lineCap, @dc.lineCap)
+      assert_equal(lineCap, @dc.getLineCap())
+    end
+  end
+
+  def testLineJoin
+    for lineJoin in [JOIN_MITER, JOIN_ROUND, JOIN_BEVEL]
+      @dc.setLineJoin(lineJoin)
+      assert_equal(lineJoin, @dc.lineJoin)
+      assert_equal(lineJoin, @dc.getLineJoin())
+      @dc.lineJoin = lineJoin
+      assert_equal(lineJoin, @dc.lineJoin)
+      assert_equal(lineJoin, @dc.getLineJoin())
+    end
+  end
+
+  def testLineStyle
+    for lineStyle in [LINE_SOLID, LINE_ONOFF_DASH, LINE_DOUBLE_DASH]
+      @dc.setLineStyle(lineStyle)
+      assert_equal(lineStyle, @dc.lineStyle)
+      assert_equal(lineStyle, @dc.getLineStyle())
+      @dc.lineStyle = lineStyle
+      assert_equal(lineStyle, @dc.lineStyle)
+      assert_equal(lineStyle, @dc.getLineStyle())
+    end
+  end
+
+  def testFillStyle
+    for fillStyle in [FILL_SOLID, FILL_TILED, FILL_STIPPLED, FILL_OPAQUESTIPPLED]
+      @dc.setFillStyle(fillStyle)
+      assert_equal(fillStyle, @dc.fillStyle)
+      assert_equal(fillStyle, @dc.getFillStyle())
+      @dc.fillStyle = fillStyle
+      assert_equal(fillStyle, @dc.fillStyle)
+      assert_equal(fillStyle, @dc.getFillStyle())
+    end
+  end
+
+  def testFillRule
+    for fillRule in [RULE_EVEN_ODD, RULE_WINDING]
+      @dc.setFillRule(fillRule)
+      assert_equal(fillRule, @dc.fillRule)
+      assert_equal(fillRule, @dc.getFillRule())
+      @dc.fillRule = fillRule
+      assert_equal(fillRule, @dc.fillRule)
+      assert_equal(fillRule, @dc.getFillRule())
+    end
+  end
+  
+  def testFunction
+    for func in [BLT_CLR, BLT_SRC_AND_DST, BLT_SRC_AND_NOT_DST, BLT_SRC,
+                 BLT_NOT_SRC_AND_DST, BLT_DST, BLT_SRC_XOR_DST, BLT_SRC_OR_DST,
+                 BLT_NOT_SRC_AND_NOT_DST, BLT_NOT_SRC_XOR_DST, BLT_NOT_DST,
+                 BLT_SRC_OR_NOT_DST, BLT_NOT_SRC, BLT_NOT_SRC_OR_DST,
+                 BLT_NOT_SRC_OR_NOT_DST, BLT_SET]
+      @dc.setFunction(func)
+      assert_equal(func, @dc.function)
+      assert_equal(func, @dc.getFunction())
+      @dc.function = func
+      assert_equal(func, @dc.function)
+      assert_equal(func, @dc.getFunction())
+    end
+  end
+  
+  def testTile
+    image, dx, dy = FXImage.new(@app), 0, 0
+    @dc.setTile(image)
+    @dc.setTile(image, dx)
+    @dc.setTile(image, dx, dy)
+    assert_same(image, @dc.tile)
+    assert_same(image, @dc.getTile())
+  end
+  
+  def testStippleBitmap
+    bitmap, dx, dy = FXBitmap.new(@app), 0, 0
+    @dc.setStipple(bitmap)
+    @dc.setStipple(bitmap, dx)
+    @dc.setStipple(bitmap, dx, dy)
+    assert_same(bitmap, @dc.stippleBitmap)
+    assert_same(bitmap, @dc.getStippleBitmap())
+  end
+  
+  def testStipplePattern
+    dx, dy = 0, 0
+    patterns = [STIPPLE_0, STIPPLE_NONE, STIPPLE_BLACK, STIPPLE_1,
+                STIPPLE_2, STIPPLE_3, STIPPLE_4, STIPPLE_5, STIPPLE_6,
+                STIPPLE_7, STIPPLE_8, STIPPLE_GRAY, STIPPLE_9, STIPPLE_10,
+                STIPPLE_11, STIPPLE_12, STIPPLE_13, STIPPLE_14, STIPPLE_15,
+                STIPPLE_16, STIPPLE_WHITE, STIPPLE_HORZ, STIPPLE_VERT, STIPPLE_CROSS,
+                STIPPLE_DIAG, STIPPLE_REVDIAG, STIPPLE_CROSSDIAG]
+    for pat in patterns
+      @dc.setStipple(pat)
+      @dc.setStipple(pat, dx)
+      @dc.setStipple(pat, dx, dy)
+      assert_equal(pat, @dc.stipplePattern)
+      assert_equal(pat, @dc.getStipplePattern())
+    end
+  end
+  
+# def testClipRegion
+#   region = FXRegion.new(0, 0, 10, 10)
+#   @dc.setClipRegion(region)
+# end
+  
+  def testClipRectangle
+    clipX, clipY, clipWidth, clipHeight = 0, 0, 10, 20
+    clipRectangle = FXRectangle.new(clipX, clipY, clipWidth, clipHeight)
+
+    @dc.setClipRectangle(clipX, clipY, clipWidth, clipHeight)
+#   assert_equal(clipX, @dc.clipX)
+#   assert_equal(clipY, @dc.clipY)
+#   assert_equal(clipWidth, @dc.clipWidth)
+#   assert_equal(clipHeight, @dc.clipHeight)
+#   assert_equal(clipRectangle, @dc.clipRectangle)
+
+    @dc.setClipRectangle(clipRectangle)
+#   assert_equal(clipX, @dc.clipX)
+#   assert_equal(clipY, @dc.clipY)
+#   assert_equal(clipWidth, @dc.clipWidth)
+#   assert_equal(clipHeight, @dc.clipHeight)
+#   assert_equal(clipRectangle, @dc.clipRectangle)
+    
+    @dc.clearClipRectangle
+  end
+  
+  def testClipMask
+    bitmap, dx, dy = FXBitmap.new(@app), 0, 0
+    @dc.setClipMask(bitmap)
+    @dc.setClipMask(bitmap, dx)
+    @dc.setClipMask(bitmap, dx, dy)
+    @dc.clearClipMask
+  end
+  
+  def testTextFont
+    textFont = @app.normalFont
+    @dc.setFont(textFont)
+    assert_same(textFont, @dc.font)
+    assert_same(textFont, @dc.getFont())
+    @dc.font = textFont
+    assert_same(textFont, @dc.font)
+    assert_same(textFont, @dc.getFont())
+  end
+  
+  def testClipChildren
+    @dc.clipChildren(true)
+    @dc.clipChildren(false)
+  end
+end

data/tests/TC_FXDCPrint.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+
+require 'fox16'
+require 'ftools'
+
+include Fox
+
+class TC_FXDCPrint < Test::Unit::TestCase
+private
+  def printJob
+    job = FXPrinter.new
+    job.name = "output.ps"
+    job.firstpage = 1
+    job.lastpage = 1
+    job.currentpage = 1
+    job.frompage = 1
+    job.topage = 1
+    job.mediasize = MEDIA_USLETTER
+    job.mediawidth = 612.0
+    job.mediaheight = 792.0
+    job.leftmargin = 72.0
+    job.rightmargin = 72.0
+    job.topmargin = 72.0
+    job.bottommargin = 72.0
+    job.numcopies = 1
+    job.flags = PRINT_DEST_FILE
+    job
+  end
+  
+  def hexdump(ios)
+    count = 0
+    ios.each_byte do |byte|
+      print sprintf("%02x ", byte)
+      count = count + 1
+      if count%8 == 0
+        print "\n"
+      end
+    end
+  end
+
+  # Convert DOS line endings (CR+LF) to Unix (LF)
+  def crlf_to_lf(text)
+    text.gsub(/\x0d\x0a/, "\x0a")
+  end
+
+  def assert_same_file_contents(expected, actual)
+    expected_contents, actual_contents = nil, nil
+    File.open(expected, 'rb') { |f| expected_contents = f.read }
+    File.open(actual, 'rb')   { |f| actual_contents = crlf_to_lf(f.read) }
+    assert_equal(expected_contents, actual_contents)
+  end
+  
+public
+  def setup
+    if FXApp.instance.nil?
+      @app = FXApp.new('TC_FXDCPrint', 'FXRuby')
+      @app.init([])
+    else
+      @app = FXApp.instance
+    end
+    @dc = FXDCPrint.new(@app)
+  end
+
+  def test_beginPrint
+    @dc.beginPrint(printJob)
+    @dc.endPrint
+    assert_same_file_contents("blankpage.ps", printJob.name)
+  end
+
+  def test_beginPrint_with_block
+    @dc.beginPrint(printJob) do |theDC|
+      assert_same(@dc, theDC)
+    end
+    assert_same_file_contents("blankpage.ps", printJob.name)
+  end
+
+  def test_beginPage
+    @dc.beginPrint(printJob)
+    @dc.beginPage(1)
+    @dc.drawText(100, 100, "Howdy!")
+    @dc.endPage
+    @dc.endPrint
+#   assert_same_file_contents("howdypage.ps", printJob.name)
+  end
+
+  def test_beginPage_with_block
+    @dc.beginPrint(printJob) do |theDC|
+      assert_same(@dc, theDC)
+      theDC.beginPage(1) do |xDC|
+        assert_same(theDC, xDC)
+        xDC.drawText(100, 100, "Howdy!")
+      end
+    end
+#   assert_same_file_contents("howdypage.ps", printJob.name)
+  end
+  
+  def teardown
+    if File.exists?("output.ps")
+      File.rm_f("output.ps")
+    end
+  end
+end

data/tests/TC_FXDCWindow.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXDCWindow < TestCase
+  def setup
+    super(self.class.name)
+    app.create
+    mainWindow.create
+  end
+  def test_new
+    dc = FXDCWindow.new(mainWindow)
+    dc.drawPoint(0, 0)
+    dc.end
+  end
+  def test_new_with_block
+    dc = FXDCWindow.new(mainWindow) do |dc|
+      dc.drawPoint(0, 0)
+    end
+  end
+end

data/tests/TC_FXDataTarget.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXDataTarget < Test::Unit::TestCase
+  def setup
+    @nilTarget    = FXDataTarget.new
+    @intTarget    = FXDataTarget.new(42)
+    @floatTarget  = FXDataTarget.new(3.14159)
+    @stringTarget = FXDataTarget.new("foo")
+    @trueTarget   = FXDataTarget.new(true)
+    @falseTarget  = FXDataTarget.new(false)
+  end
+  def test_to_s
+    assert_equal("", @nilTarget.to_s)
+    assert_equal("42", @intTarget.to_s)
+    assert_equal("3.14159", @floatTarget.to_s)
+    assert_equal("foo", @stringTarget.to_s)
+    assert_equal("true", @trueTarget.to_s)
+    assert_equal("false", @falseTarget.to_s)
+  end
+end
+

data/tests/TC_FXDirList.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXDirList < TestCase
+  def setup
+    super(self.class.name)
+    @dirList = FXDirList.new(mainWindow)
+  end
+
+  def test_setCurrentFile
+    file = ""
+    @dirList.setCurrentFile(file)
+    @dirList.setCurrentFile(file, true)
+  end
+
+  def test_setDirectory
+    path = ""
+    @dirList.setDirectory(path)
+    @dirList.setDirectory(path, true)
+  end
+
+  def test_getPathnameItem
+    path = ""
+    @dirList.getPathnameItem(path)
+  end
+end
+

data/tests/TC_FXFileAssoc.rb

@@ -0,0 +1,62 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXFileAssoc < Test::Unit::TestCase
+  def setup
+    @app = FXApp.instance || FXApp.new
+    @icon = FXIcon.new(@app)
+    @fileassoc = FXFileAssoc.new
+  end
+  
+  def test_command
+    @fileassoc.command = "netscape"
+    assert_equal("netscape", @fileassoc.command)
+  end
+  
+  def test_extension
+    @fileassoc.extension = ".html"
+    assert_equal(".html", @fileassoc.extension)
+  end
+  
+  def test_mimetype
+    @fileassoc.mimetype = "mimetype"
+    assert_equal("mimetype", @fileassoc.mimetype)
+  end
+  
+  def test_bigicon
+    @fileassoc.bigicon = @icon
+    assert_kind_of(FXIcon, @fileassoc.bigicon)
+    assert_same(@icon, @fileassoc.bigicon)
+  end
+
+  def test_bigiconopen
+    @fileassoc.bigiconopen = @icon
+    assert_kind_of(FXIcon, @fileassoc.bigiconopen)
+    assert_same(@icon, @fileassoc.bigiconopen)
+  end
+
+  def test_miniicon
+    @fileassoc.miniicon = @icon
+    assert_kind_of(FXIcon, @fileassoc.miniicon)
+    assert_same(@icon, @fileassoc.miniicon)
+  end
+
+  def test_miniiconopen
+    @fileassoc.miniiconopen = @icon
+    assert_kind_of(FXIcon, @fileassoc.miniiconopen)
+    assert_same(@icon, @fileassoc.miniiconopen)
+  end
+
+  def test_dragtype
+    @fileassoc.dragtype = 0
+    assert_equal(0, @fileassoc.dragtype)
+  end
+  
+  def test_flags
+    @fileassoc.flags = 0
+    assert_equal(0, @fileassoc.flags)
+  end
+end

data/tests/TC_FXFileStream.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+require 'fox16'
+require 'ftools'
+require 'tempfile'
+
+include Fox
+
+class TC_FXFileStream < Test::Unit::TestCase
+  def setup
+    @filestream = FXFileStream.new
+  end
+
+  def test_container
+    assert_nil(@filestream.container)
+  end
+  
+  def test_open_non_existing_file
+    assert_equal(FXStreamDead, @filestream.direction)
+    status = @filestream.open("non_existing_file", FXStreamLoad)
+    assert(!status)
+    assert_equal(FXStreamDead, @filestream.direction)
+  end
+
+  def test_open_existing_file
+    assert_equal(FXStreamDead, @filestream.direction)
+    status = @filestream.open("README", FXStreamLoad)
+    assert(status)
+    assert_equal(FXStreamLoad, @filestream.direction)
+    status = @filestream.close
+    assert(status)
+    assert_equal(FXStreamDead, @filestream.direction)
+  end
+
+  def test_open_new_file
+    assert_equal(FXStreamDead, @filestream.direction)
+    status = @filestream.open("goobers", FXStreamSave)
+    assert(status)
+    assert_equal(FXStreamSave, @filestream.direction)
+    status = @filestream.close
+    assert(status)
+    assert_equal(FXStreamDead, @filestream.direction)
+  end
+  
+  def test_status
+    assert_equal(FXStreamOK, @filestream.status)
+    @filestream.open("README", FXStreamLoad)
+    assert_equal(FXStreamOK, @filestream.status)
+    @filestream.close
+    assert_equal(FXStreamOK, @filestream.status)
+  end
+  
+  def test_position
+    @filestream.open("README", FXStreamLoad)
+    assert_equal(0, @filestream.position)
+    @filestream.position = 500
+    assert_equal(500, @filestream.position)
+    @filestream.close
+  end
+  
+  def test_exceptions
+    # Non-existing file
+    assert_raises(FXStreamNoReadError) {
+      FXFileStream.open("non_existing_file", FXStreamLoad) { |s| }
+    }
+
+    # Write-only file (i.e. no read permissions)
+    tf = Tempfile.new("write_only_file")
+    tf.puts("junk")
+    tf.close
+    File.chmod(0222, tf.path) # --w--w--w-
+    assert_raises(FXStreamNoReadError) {
+      FXFileStream.open(tf.path, FXStreamLoad) { |s| }
+    }
+
+    # Read-only file
+    tf = Tempfile.new("read_only_file")
+    tf.puts("junk")
+    tf.close
+    File.chmod(0444, tf.path) # -r--r--r--
+    assert_raises(FXStreamNoWriteError) {
+      FXFileStream.open(tf.path, FXStreamSave) { |s| }
+    }
+  end
+  
+  def teardown
+    if File.exists?("goobers")
+      File.rm_f("goobers")
+    end
+  end
+end