fxruby 1.6.14-universal-darwin-9

data/tests/TC_FXImage.rb

@@ -0,0 +1,155 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXImage < TestCase
+  def setup
+    super(self.class.name)
+  end
+
+  def test_default_constructor_args_1
+    img = FXImage.new(app)
+    assert_same(nil, img.data)
+    assert_equal(0, img.options)
+    assert_equal(1, img.width)
+    assert_equal(1, img.height)
+  end
+  
+  def test_default_constructor_args_2
+    img = FXImage.new(app, nil)
+    assert_same(nil, img.data)
+    assert_equal(0, img.options)
+    assert_equal(1, img.width)
+    assert_equal(1, img.height)
+  end
+
+  def test_default_constructor_args_3
+    img = FXImage.new(app, nil, 0)
+    assert_same(nil, img.data)
+    assert_equal(0, img.options)
+    assert_equal(1, img.width)
+    assert_equal(1, img.height)
+  end
+
+  def test_default_constructor_args_4
+    img = FXImage.new(app, nil, 0, 1)
+    assert_same(nil, img.data)
+    assert_equal(0, img.options)
+    assert_equal(1, img.width)
+    assert_equal(1, img.height)
+  end
+
+  def test_default_constructor_args_5
+    img = FXImage.new(app, nil, 0, 1, 1)
+    assert_same(nil, img.data)
+    assert_equal(0, img.options)
+    assert_equal(1, img.width)
+    assert_equal(1, img.height)
+  end
+
+  def test_new_image_nil_pixels_owned
+    img = FXImage.new(app, nil, IMAGE_OWNED)
+    assert_equal(1, img.width)
+    assert_equal(1, img.height)
+    data = img.data
+    assert_instance_of(FXMemoryBuffer, data)
+    assert_equal(1*1, data.size)
+    assert_equal(IMAGE_OWNED, img.options)
+  end
+
+  def test_create
+    #
+    # If the image owns its pixel data and IMAGE_KEEP was not specified,
+    # the data should go away after we call create.
+    #
+    img = FXImage.new(app, nil, IMAGE_OWNED)
+    assert_not_nil(img.data)
+    img.create
+    assert_nil(img.data)
+
+    #
+    # If the image owns its pixel data and IMAGE_KEEP was specified,
+    # the data should stay after we call create.
+    #
+    img = FXImage.new(app, nil, IMAGE_KEEP|IMAGE_OWNED)
+    assert_not_nil(img.data)
+    img.create
+    assert_not_nil(img.data)
+  end
+
+  #
+  # Restore client-side pixel buffer from image.
+  #
+  def test_restore
+    #
+    # If no client-side pixel buffer exists at the time that
+    # restore() is called, this should create one and set the
+    # IMAGE_OWNED option.
+    #
+    img = FXImage.new(app)
+    img.create
+    assert_nil(img.data)
+    assert_equal(0, img.options&IMAGE_OWNED)
+    img.restore
+    assert_not_nil(img.data)
+    assert_not_equal(0, img.options&IMAGE_OWNED)
+  end
+  
+  # Render client-side pixel buffer into pixmap
+  def test_render
+    # Test without client-side pixel buffer
+    img = FXImage.new(app)
+    img.render
+  end
+
+=begin
+
+  def test_scale
+    img.scale(2, 2, 0)
+    img.scale(2, 2, 1)
+  end
+  
+  def test_mirror
+  end
+  
+  def test_rotate
+  end
+  
+  def test_crop
+  end
+  
+  def test_fill
+  end
+  
+  def test_fade
+  end
+  
+  def test_xshear
+  end
+  
+  def test_yshear
+  end
+  
+  def test_hgradient
+  end
+  
+  def test_vgradient
+  end
+  
+  def test_gradient
+  end
+  
+  def test_blend
+  end
+  
+  def test_savePixels
+  end
+  
+  def test_loadPixels
+  end
+  
+=end
+
+end

data/tests/TC_FXLight.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXLight < Test::Unit::TestCase
+  def setup
+    @light = FXLight.new
+  end
+  def testAttributes
+    assert(@light.ambient)
+    assert_kind_of(FXVec4f, @light.ambient)
+    assert(@light.diffuse)
+    assert_kind_of(FXVec4f, @light.diffuse)
+    assert(@light.specular)
+    assert_kind_of(FXVec4f, @light.specular)
+    assert(@light.position)
+    assert_kind_of(FXVec4f, @light.position)
+    assert(@light.direction)
+    assert_kind_of(FXVec3f, @light.direction)
+    assert(@light.exponent)
+    assert_kind_of(Float, @light.exponent)
+    assert(@light.cutoff)
+    assert_kind_of(Float, @light.cutoff)
+    assert(@light.c_attn)
+    assert_kind_of(Float, @light.c_attn)
+    assert(@light.l_attn)
+    assert_kind_of(Float, @light.l_attn)
+    assert(@light.q_attn)
+    assert_kind_of(Float, @light.q_attn)
+  end
+end

data/tests/TC_FXList.rb

@@ -0,0 +1,116 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXList < TestCase
+  def setup
+    super(self.class.name)
+    @list = FXList.new(mainWindow)
+  end
+  
+  def test_numVisible
+    @list.numVisible = 7
+    assert_equal(7, @list.numVisible)
+  end
+  
+  def test_appendItem_byItem
+    items = []
+    0.upto(4) do |i|
+      items << FXListItem.new("item#{i}")
+    end
+    assert_equal(0, @list.numItems)
+    @list.appendItem(items[0])
+    assert_equal(1, @list.numItems)
+    @list.appendItem(items[1], true)
+    assert_equal(2, @list.numItems)
+    @list.appendItem(items[2], false)
+    assert_equal(3, @list.numItems)
+    assert_raises(ArgumentError) do
+      @list.appendItem(items[3], 42) # second argument must be true or false
+    end
+    assert_equal(3, @list.numItems)
+  end
+
+  def test_appendOp
+    assert_equal(0, @list.numItems)
+    @list << FXListItem.new("item1")
+    assert_equal(1, @list.numItems)
+    @list << FXListItem.new("item2")
+    assert_equal(2, @list.numItems)
+    @list << FXListItem.new("item3")
+    assert_equal(3, @list.numItems)
+  end
+  
+  def test_appendItem_byText
+    assert_equal(0, @list.numItems)
+    itemIndex = @list.appendItem("")
+    assert_equal(1, @list.numItems)
+    itemIndex = @list.appendItem("anItem")
+    assert_equal(2, @list.numItems)
+    itemIndex = @list.appendItem("anItem", nil)
+    assert_equal(3, @list.numItems)
+    itemIndex = @list.appendItem("anItem", nil, "someData")
+    assert_equal(4, @list.numItems)
+    itemIndex = @list.appendItem("anItem", nil, "someData", true)
+    assert_equal(5, @list.numItems)
+    itemIndex = @list.appendItem("anItem", nil, "someData", false)
+    assert_equal(6, @list.numItems)
+    assert_raises(ArgumentError) do
+      @list.appendItem("anItem", nil, "someData", 42) # last argument must be true or false
+    end
+    assert_equal(6, @list.numItems)
+  end
+  
+  def test_getItem
+    assert_raises(IndexError) {
+      @list.getItem(0)
+    }
+    theItem = FXListItem.new("anItem")
+    @list << theItem
+    retrievedItem = nil
+    assert_nothing_raised {
+      retrievedItem = @list.getItem(0)
+    }
+    assert_same(theItem, retrievedItem)
+  end
+
+  def test_moveItem
+    @list.appendItem("First")
+    @list.appendItem("Second")
+    assert_raises(IndexError) {
+      @list.moveItem(0, -1)
+    }
+    assert_raises(IndexError) {
+      @list.moveItem(0, 2)
+    }
+    assert_raises(IndexError) {
+      @list.moveItem(-1, 0)
+    }
+    assert_raises(IndexError) {
+      @list.moveItem(2, 0)
+    }
+    assert_nothing_raised {
+      @list.moveItem(0, 0)
+      @list.moveItem(0, 1)
+      @list.moveItem(1, 0)
+      @list.moveItem(1, 1)
+    }
+    assert_equal(0, @list.moveItem(0, 1))
+    assert_equal(1, @list.moveItem(1, 0))
+  end
+  
+  def test_makeItemVisible
+    items = []
+    0.upto(2) { |i|
+      items << @list.appendItem("item#{i}")
+    }
+    assert_raises(IndexError) {
+      @list.makeItemVisible(-1)
+    }
+    assert_raises(IndexError) {
+      @list.makeItemVisible(3)
+    }
+  end
+end

data/tests/TC_FXListBox.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXListBox < TestCase
+  def setup
+    super(self.class.name)
+    @listBox = FXListBox.new(mainWindow)
+  end
+  
+  def test_appendItem
+    assert_equal(0, @listBox.numItems)
+    @listBox.appendItem("An item")
+    assert_equal(1, @listBox.numItems)
+  end
+
+  def test_appendOp
+    assert_equal(0, @listBox.numItems)
+    @listBox << "An item"
+    assert_equal(1, @listBox.numItems)
+  end
+
+  def test_moveItem
+    @listBox.appendItem("First")
+    @listBox.appendItem("Second")
+    assert_raises(IndexError) {
+      @listBox.moveItem(0, -1)
+    }
+    assert_raises(IndexError) {
+      @listBox.moveItem(0, 2)
+    }
+    assert_raises(IndexError) {
+      @listBox.moveItem(-1, 0)
+    }
+    assert_raises(IndexError) {
+      @listBox.moveItem(2, 0)
+    }
+    assert_nothing_raised {
+      @listBox.moveItem(0, 0)
+      @listBox.moveItem(0, 1)
+      @listBox.moveItem(1, 0)
+      @listBox.moveItem(1, 1)
+    }
+    assert_equal(0, @listBox.moveItem(0, 1))
+    assert_equal(1, @listBox.moveItem(1, 0))
+  end
+end

data/tests/TC_FXMat4f.rb

@@ -0,0 +1,228 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXMat4f < Test::Unit::TestCase
+  def setup
+    @hmat = FXMat4f.new
+  end
+  
+  def test_initialize
+    h = FXMat4f.new
+    assert_instance_of(FXMat4f, h)
+  end
+  
+  def test_from_w
+    w = 0.0
+    h = FXMat4f.new(w)
+    assert_instance_of(FXMat4f, h)
+  end
+  
+  def test_from_elements
+    a00, a01, a02, a03 = 0.0, 0.0, 0.0, 0.0
+    a10, a11, a12, a13 = 0.0, 0.0, 0.0, 0.0
+    a20, a21, a22, a23 = 0.0, 0.0, 0.0, 0.0
+    a30, a31, a32, a33 = 0.0, 0.0, 0.0, 0.0
+    h = FXMat4f.new(a00, a01, a02, a03,
+                   a10, a11, a12, a13,
+		   a20, a21, a22, a23,
+		   a30, a31, a32, a33)
+    assert_instance_of(FXMat4f, h)
+  end
+  
+  def test_from_row_vectors
+    a = FXVec4f.new(0.0, 0.0, 0.0, 0.0)
+    b = FXVec4f.new(0.0, 0.0, 0.0, 0.0)
+    c = FXVec4f.new(0.0, 0.0, 0.0, 0.0)
+    d = FXVec4f.new(0.0, 0.0, 0.0, 0.0)
+    h = FXMat4f.new(a, b, c, d)
+    assert_instance_of(FXMat4f, h)
+  end
+  
+  def test_copy
+    anotherHMat = FXMat4f.new(@hmat)
+    assert_instance_of(FXMat4f, anotherHMat)
+    assert_not_same(@hmat, anotherHMat)
+#   assert_equal(@hmat, anotherHMat)
+  end
+  
+  def test_add
+    anotherMat = FXMat4f.new
+    sum1 = anotherMat + @hmat
+    sum2 = @hmat + anotherMat
+    assert_instance_of(FXMat4f, sum1)
+    assert_instance_of(FXMat4f, sum2)
+#   assert_equal(sum1, sum2)
+  end
+  
+  def test_neg
+    neg = -@hmat
+    assert_instance_of(FXMat4f, neg)
+  end
+  
+  def test_sub
+    anotherMat = FXMat4f.new
+    diff1 = anotherMat - @hmat
+    diff2 = @hmat - anotherMat
+    assert_instance_of(FXMat4f, diff1)
+    assert_instance_of(FXMat4f, diff2)
+#   assert_equal(diff1, -diff2)
+  end
+  
+  def test_mul_matrices
+    a = FXMat4f.new
+    b = FXMat4f.new
+    product = a*b
+    assert_instance_of(FXMat4f, product)
+#   assert_equal(product, b*a)
+  end
+  
+  def test_mul_by_scalar
+    p = FXMat4f.new.eye
+    q = FXMat4f.new(4.0, 0.0, 0.0, 0.0,
+                   0.0, 4.0, 0.0, 0.0,
+		   0.0, 0.0, 4.0, 0.0,
+		   0.0, 0.0, 0.0, 4.0)
+    r = p*4.0
+    assert_instance_of(FXMat4f, r)
+#   assert_equal(q, r)
+  end
+  
+  def test_div
+    quotient = @hmat/2.0
+    assert_instance_of(FXMat4f, quotient)
+  end
+  
+  def test_det
+    det = @hmat.det
+    assert_instance_of(Float, det)
+  end
+  
+  def test_transpose
+    transposed = @hmat.transpose
+    assert_instance_of(FXMat4f, transposed)
+  end
+  
+  def test_invert
+    identity = FXMat4f.new.eye
+    inverted = identity.invert
+    assert_instance_of(FXMat4f, inverted)
+  end
+  
+  def test_eye
+    eye = @hmat.eye
+    assert_same(@hmat, eye)
+  end
+  
+  def test_ortho
+    left, right, bottom, top, hither, yon = 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
+    ortho = @hmat.ortho(left, right, bottom, top, hither, yon)
+    assert_same(@hmat, ortho)
+  end
+  
+  def test_frustum
+    left, right, bottom, top, hither, yon = 0.0, 1.0, 0.0, 1.0, 0.1, 1.0
+    frustum = @hmat.frustum(left, right, bottom, top, hither, yon)
+    assert_same(@hmat, frustum)
+  end
+  
+  def test_left
+    left = @hmat.left
+    assert_same(@hmat, left)
+  end
+  
+  def test_rot_q
+    q = FXQuatf.new
+    rot = @hmat.rot(q)
+    assert_same(@hmat, rot)
+  end
+  
+  def test_rot_c_s_axis
+    axis = FXVec3f.new
+    c, s = 0.0, 0.0
+    rot = @hmat.rot(axis, c, s)
+    assert_same(@hmat, rot)
+  end
+  
+  def test_rot_phi_axis
+    axis = FXVec3f.new
+    phi = 45.0
+    rot = @hmat.rot(axis, phi)
+    assert_same(@hmat, rot)
+  end
+  
+  def test_xrot_c_s
+    c, s = 0.0, 0.0
+    xrot = @hmat.xrot(c, s)
+    assert_same(@hmat, xrot)
+  end
+  
+  def test_xrot_phi
+    phi = 22.5
+    xrot = @hmat.xrot(phi)
+    assert_same(@hmat, xrot)
+  end
+  
+  def test_yrot_c_s
+    c, s = 0.0, 0.0
+    yrot = @hmat.yrot(c, s)
+    assert_same(@hmat, yrot)
+  end
+  
+  def test_yrot_phi
+    phi = 22.5
+    yrot = @hmat.yrot(phi)
+    assert_same(@hmat, yrot)
+  end
+  
+  def test_zrot_c_s
+    c, s = 0.0, 0.0
+    zrot = @hmat.zrot(c, s)
+    assert_same(@hmat, zrot)
+  end
+  
+  def test_zrot_phi
+    phi = 22.5
+    zrot = @hmat.zrot(phi)
+    assert_same(@hmat, zrot)
+  end
+  
+  def test_look
+    eye = FXVec3f.new
+    cntr = FXVec3f.new
+    vup = FXVec3f.new
+    look = @hmat.look(eye, cntr, vup)
+    assert_same(@hmat, look)
+  end
+  
+  def test_trans_txyz
+    tx, ty, tz = 0.0, 0.0, 0.0
+    translated = @hmat.trans(tx, ty, tz)
+    assert_same(@hmat, translated)
+  end
+  
+  def test_trans_vec
+    v = FXVec3f.new(0.0, 0.0, 0.0)
+    translated = @hmat.trans(v)
+    assert_same(@hmat, translated)
+  end
+  
+  def test_scale_sxyz
+    sx, sy, sz = 1.0, 1.0, 1.0
+    scaled = @hmat.scale(sx, sy, sz)
+    assert_same(@hmat, scaled)
+  end
+  
+  def test_scale_s
+    s = 1.0
+    scaled = @hmat.scale(s)
+    assert_same(@hmat, scaled)
+  end
+  
+  def test_scale_vec
+    v = FXVec3f.new(1.0, 1.0, 1.0)
+    scaled = @hmat.scale(v)
+    assert_same(@hmat, scaled)
+  end
+end

data/tests/TC_FXMaterial.rb

@@ -0,0 +1,89 @@
+require 'test/unit'
+
+require 'fox16'
+require 'fox16/glshapes'
+
+include Fox
+
+class TC_FXMaterial < Test::Unit::TestCase
+
+  DELTA = 1.0e-6
+  
+  def setup
+    @mat = FXMaterial.new
+  end
+  
+  def test_ambient
+    @mat.ambient = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.ambient[0], DELTA)
+    assert_in_delta(0.6, @mat.ambient[1], DELTA)
+    assert_in_delta(0.7, @mat.ambient[2], DELTA)
+    assert_in_delta(0.8, @mat.ambient[3], DELTA)
+
+    @mat.ambient = FXVec4f.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.ambient[0], DELTA)
+    assert_in_delta(0.6, @mat.ambient[1], DELTA)
+    assert_in_delta(0.7, @mat.ambient[2], DELTA)
+    assert_in_delta(0.8, @mat.ambient[3], DELTA)
+  end
+  
+  def test_diffuse
+    @mat.diffuse = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.diffuse[0], DELTA)
+    assert_in_delta(0.6, @mat.diffuse[1], DELTA)
+    assert_in_delta(0.7, @mat.diffuse[2], DELTA)
+    assert_in_delta(0.8, @mat.diffuse[3], DELTA)
+
+    @mat.diffuse = FXVec4f.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.diffuse[0], DELTA)
+    assert_in_delta(0.6, @mat.diffuse[1], DELTA)
+    assert_in_delta(0.7, @mat.diffuse[2], DELTA)
+    assert_in_delta(0.8, @mat.diffuse[3], DELTA)
+  end
+  
+  def test_emission
+    @mat.emission = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+
+    @mat.emission = FXHVec.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+  end
+  
+  def test_emission
+    @mat.emission = [0.5, 0.6, 0.7, 0.8]
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+
+    @mat.emission = FXVec4f.new(0.5, 0.6, 0.7, 0.8)
+    assert_in_delta(0.5, @mat.emission[0], DELTA)
+    assert_in_delta(0.6, @mat.emission[1], DELTA)
+    assert_in_delta(0.7, @mat.emission[2], DELTA)
+    assert_in_delta(0.8, @mat.emission[3], DELTA)
+  end
+  
+  def test_shininess
+    @mat.shininess = 0.5
+    assert_in_delta(0.5, @mat.shininess, DELTA)
+  end
+
+  def test_bug
+    cube = FXGLCube.new(0, 0, 0, 0, 0)
+    mat = FXMaterial.new
+    mat.diffuse  = FXVec4f.new(0, 0, 0, 0)
+    mat.specular = FXVec4f.new(0, 0, 0, 0)
+    mat.ambient  = FXVec4f.new(0, 0, 0, 0)
+    cube.setMaterial(0, mat)
+    mat2 = cube.getMaterial(0)
+    assert_instance_of(FXVec4f, mat2.ambient)
+    assert_instance_of(FXVec4f, mat2.specular)
+    assert_instance_of(FXVec4f, mat2.diffuse)
+  end
+end