wxruby3 0.9.0.pre.beta.2-x64-mingw-ucrt-3.2-3.2.2

data/tests/test_events.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'wx'
+
+class EventTests < Test::Unit::TestCase
+
+  def test_event
+    evt = Wx::Event.new(100, 1)
+    assert_equal(100, evt.event_type)
+    assert_equal(1, evt.id)
+    assert_boolean(!evt.should_propagate)
+    evt.skip
+    assert_boolean(evt.skipped)
+    evt_dup = evt.clone
+    assert_not_equal(evt, evt_dup)
+    assert_equal(evt.event_type, evt_dup.event_type)
+    assert_equal(evt.id, evt_dup.id)
+  end
+
+  def test_command_event
+    evt = Wx::CommandEvent.new(100, 1)
+    assert_equal(100, evt.event_type)
+    assert_equal(1, evt.id)
+    assert_boolean(evt.should_propagate)
+    evt.skip
+    assert_boolean(evt.skipped)
+    evt.string = 'CommandEvent Test'
+    assert_equal('CommandEvent Test', evt.string)
+    evt_dup = evt.clone
+    assert_not_equal(evt, evt_dup)
+    assert_equal(evt.event_type, evt_dup.event_type)
+    assert_equal(evt.id, evt_dup.id)
+    assert_equal(evt.string, evt_dup.string)
+  end
+end
+
+class TestApp < Wx::App
+  def on_init
+    Test::Unit::UI::Console::TestRunner.run(EventTests)
+    false
+  end
+end
+
+app = TestApp.new
+app.run

data/tests/test_geometry.rb

@@ -0,0 +1,141 @@
+require 'test/unit'
+require 'wx'
+
+class GeometryTests < Test::Unit::TestCase
+
+  def test_size
+    sz = Wx::Size.new(10, 20)
+    assert_equal(10, sz.width)
+    assert_equal(20, sz.height)
+
+    w, h = sz
+    assert_equal(10, w)
+    assert_equal(20, h)
+
+    assert(sz == Wx::Size.new(w,h))
+    assert(sz == [w,h])
+    assert_raise(TypeError) { sz == '10, 20' }
+
+    assert(sz.eql? Wx::Size.new(w,h))
+    refute(sz.eql?([w,h]))
+
+    assert(Wx::Size.new(5,10).eql?(sz/2))
+
+    assert(Wx::Size.new(20,40).eql?(sz*2))
+
+    assert(Wx::Size.new(8,18).eql?(sz - 2))
+    assert(Wx::Size.new(8,17).eql?(sz - Wx::Size.new(2,3)))
+    assert(Wx::Size.new(8,17).eql?(sz - [2,3]))
+
+    assert(Wx::Size.new(12,22).eql?(sz + 2))
+    assert(Wx::Size.new(12,23).eql?(sz + Wx::Size.new(2,3)))
+    assert(Wx::Size.new(12,23).eql?(sz + [2,3]))
+  end
+
+  def test_point
+    pt = Wx::Point.new(10, 20)
+    assert_equal(10, pt.x)
+    assert_equal(20, pt.y)
+
+    x, y = pt
+    assert_equal(10, x)
+    assert_equal(20, y)
+
+    assert(pt == Wx::Point.new(x,y))
+    assert(pt == [x,y])
+    assert_raise(TypeError) { pt == '10, 20' }
+
+    assert(pt.eql? Wx::Point.new(x,y))
+    refute(pt.eql?([x,y]))
+
+    assert(Wx::Point.new(5,10).eql?(pt/2))
+
+    assert(Wx::Point.new(20,40).eql?(pt*2))
+
+    assert(Wx::Point.new(8,18).eql?(pt - 2))
+    assert(Wx::Point.new(8,17).eql?(pt - Wx::Point.new(2,3)))
+    assert(Wx::Point.new(8,17).eql?(pt - Wx::Size.new(2,3)))
+    assert(Wx::Point.new(8,17).eql?(pt - [2,3]))
+
+    assert(Wx::Point.new(12,22).eql?(pt + 2))
+    assert(Wx::Point.new(12,23).eql?(pt + Wx::Point.new(2,3)))
+    assert(Wx::Point.new(12,23).eql?(pt + Wx::Size.new(2,3)))
+    assert(Wx::Point.new(12,23).eql?(pt + [2,3]))
+  end
+
+  def test_real_point
+    pt = Wx::RealPoint.new(10.0, 20.0)
+    assert_equal(10.0, pt.x)
+    assert_equal(20.0, pt.y)
+
+    x, y = pt
+    assert_equal(10.0, x)
+    assert_equal(20.0, y)
+
+    assert(pt == Wx::RealPoint.new(x,y))
+    assert(pt == [x,y])
+    assert_raise(TypeError) { pt == '10.0, 20.0' }
+
+    assert(pt.eql? Wx::RealPoint.new(x,y))
+    refute(pt.eql?([x,y]))
+
+    assert(Wx::RealPoint.new(5.0,10.0).eql?(pt/2))
+
+    assert(Wx::RealPoint.new(20.0,40.0).eql?(pt*2))
+
+    assert(Wx::RealPoint.new(8.0,18.0).eql?(pt - 2))
+    assert(Wx::RealPoint.new(8.0,17.0).eql?(pt - Wx::RealPoint.new(2.0,3.0)))
+    assert(Wx::RealPoint.new(8.0,17.0).eql?(pt - Wx::Point.new(2,3)))
+    assert(Wx::RealPoint.new(8.0,17.0).eql?(pt - Wx::Size.new(2,3)))
+    assert(Wx::RealPoint.new(8.0,17.0).eql?(pt - [2,3]))
+
+    assert(Wx::RealPoint.new(12.0,22.0).eql?(pt + 2))
+    assert(Wx::RealPoint.new(12.0,23.0).eql?(pt + Wx::RealPoint.new(2.0,3.0)))
+    assert(Wx::RealPoint.new(12.0,23.0).eql?(pt + Wx::Point.new(2,3)))
+    assert(Wx::RealPoint.new(12.0,23.0).eql?(pt + Wx::Size.new(2,3)))
+    assert(Wx::RealPoint.new(12.0,23.0).eql?(pt + [2,3]))
+  end
+
+  def test_rect
+    rect = Wx::Rect.new(1, 10, 100, 300)
+    assert_equal(1, rect.x)
+    assert_equal(10, rect.y)
+    assert_equal(1, rect.left)
+    assert_equal(10, rect.top)
+    assert_equal(100, rect.width)
+    assert_equal(300, rect.height)
+    assert_equal(100, rect.right)
+    assert_equal(309, rect.bottom)
+
+    x, y, w, h = rect
+    assert_equal(1, x)
+    assert_equal(10, y)
+    assert_equal(100, w)
+    assert_equal(300, h)
+
+    assert(rect == Wx::Rect.new(x,y,w,h))
+    assert(rect == [x,y,w,h])
+    assert_raise(TypeError) { rect == '10,0,20,0' }
+
+    assert(rect.eql? Wx::Rect.new(x,y,w,h))
+    refute(rect.eql?([x,y,w,h]))
+
+    assert_equal(Wx::Rect.new(1, 10, 101, 310), (rect | Wx::Rect.new(2, 20, 100, 300)))
+    assert_equal(Wx::Rect.new(1, 10, 101, 310), (rect + Wx::Rect.new(2, 20, 100, 300)))
+    assert_equal(Wx::Rect.new(1, 10, 100, 300), (rect | Wx::Rect.new(2, 20, 0, 300)))
+    assert_equal(Wx::Rect.new(1, 10, 100, 310), (rect + Wx::Rect.new(2, 20, 0, 300)))
+
+    assert_equal(Wx::Rect.new(2, 20, 99, 290), (rect & Wx::Rect.new(2, 20, 100, 300)))
+    assert_equal(Wx::Rect.new(2, 20, 99, 290), (rect * Wx::Rect.new(2, 20, 100, 300)))
+    assert_equal(Wx::Rect.new(2, 20, 0, 0), (rect & Wx::Rect.new(2, 20, 0, 300)))
+    assert_equal(Wx::Rect.new(2, 20, 0, 290), (rect * Wx::Rect.new(2, 20, 0, 300)))
+    assert_equal(Wx::Rect.new(102, 20, 0, 0), (rect & Wx::Rect.new(102, 20, 100, 300)))
+    assert_equal(Wx::Rect.new(102, 20, -1, 290), (rect * Wx::Rect.new(102, 20, 100, 300)))
+  end
+
+end
+
+if $0 == __FILE__
+  require 'test/unit/ui/console/testrunner'
+  Test::Unit::UI::Console::TestRunner.run(GeometryTests)
+end

data/tests/test_intl.rb

@@ -0,0 +1,107 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'wx'
+
+class TestApp < Wx::App
+  attr_accessor :test_class
+  def on_init
+    Test::Unit::UI::Console::TestRunner.run(self.test_class)
+    false # exit after tests
+  end
+end
+
+class TestInternationalisation < Test::Unit::TestCase
+  def test_encodings
+    default = Wx::Font.get_default_encoding
+    assert_kind_of(Wx::FontEncoding, default)
+    assert_kind_of(String, Wx::Font.get_default_encoding_name)
+    assert_match(/\A[-A-Z0-9]+\z/, Wx::Font.get_default_encoding_name)
+
+    Wx::Font.set_default_encoding(Wx::FONTENCODING_UTF8)
+    assert_equal(Wx::FONTENCODING_UTF8, Wx::Font.get_default_encoding)
+    assert_equal('UTF8', Wx::Font.get_default_encoding_name)
+
+    Wx::Font.set_default_encoding(default)
+    assert_equal(default, Wx::Font.get_default_encoding)
+
+    Wx::Font.set_default_encoding_name('ISO-8859-1')
+    assert_equal(Wx::FONTENCODING_ISO8859_1, Wx::Font.get_default_encoding)
+    assert_equal('ISO-8859-1', Wx::Font.get_default_encoding_name)
+
+    Wx::Font.set_default_encoding(default)
+  end
+
+  def test_language_info
+    locale_info = Wx::Locale.find_language_info('en')
+    assert_equal('English', locale_info.description)
+
+    locale_info = Wx::Locale.find_language_info('pt_BR')
+    assert_equal('Portuguese (Brazil)', locale_info.description)
+
+    locale_info = Wx::Locale.find_language_info('ja')
+    assert_equal('Japanese', locale_info.description)
+
+    assert_nil( Wx::Locale.find_language_info('xx') )
+  end
+  
+  # def test_add_language_info
+  #   flunk 'Wx::Locale.add_language is not yet implemented'
+  #   # FIXME - typemaps for wxString are not picked up when SWIG converts
+  #   # the struct definition; so maybe do an %extend for this method that
+  #   # accepts string canonical name and description and Win32
+  #   # identifiers, and returns an integer id. See Locale.i
+  #   language_marain = Wx::Locale.add_language('ma_MA', 'Marain',
+  #                                              0, 0)
+  #   assert_kind_of(Integer, language_marain)
+  #   lang_info = Wx::Locale.find_language_info('ma_MA')
+  #   assert_equal(Wx::LANGUAGE_MARAIN, lang_info.language)
+  #   assert_equal('ma_MA', lang_info.canonical_name)
+  #   assert_equal('Marain', lang_info.description)
+  # end
+
+  def test_get_system_language
+    sys_lang = Wx::Locale.get_system_language
+    assert_kind_of(Integer, sys_lang)
+
+    assert(Wx::Locale.is_available(sys_lang), 'System language is available')
+    assert_kind_of(String, Wx::Locale.get_system_language_name)
+
+    assert_kind_of(Wx::FontEncoding, Wx::Locale.get_system_encoding)
+    assert_kind_of(String, Wx::Locale.get_system_encoding_name)
+    assert_match(/\A[-A-Z0-9]+\z/, Wx::Locale.get_system_encoding_name)
+  end
+
+  def test_set_locales
+    time = Time.local(2006, 10, 25, 16, 48, 12)
+
+    # setting via Locale.set_locale
+    if Wx::Locale.is_available(Wx::LANGUAGE_ENGLISH_UK)
+      locale = Wx::Locale.set_locale('en_GB')
+      assert_equal('en_GB', locale.get_canonical_name)
+      assert_equal(Wx::LANGUAGE_ENGLISH_UK, locale.get_language)
+      assert_equal('English (United Kingdom)', locale.get_language_name)
+    end
+
+    if Wx::Locale.is_available(Wx::LANGUAGE_ENGLISH_US)
+      locale = Wx::Locale.set_locale('en_US')
+      assert_equal('en_US', locale.get_canonical_name)
+      assert_equal(Wx::LANGUAGE_ENGLISH_US, locale.get_language)
+      assert_equal('English (United States)', locale.get_language_name)
+    end
+
+    # setting via Locale.new
+    if Wx::Locale.is_available(Wx::LANGUAGE_DANISH)
+      locale = Wx::Locale.new(Wx::LANGUAGE_DANISH)
+      assert_equal('da_DK', locale.get_canonical_name)
+      assert_equal(Wx::LANGUAGE_DANISH, locale.get_language)
+      assert_equal('Danish', locale.get_language_name)
+    end
+
+    assert_raises(ArgumentError) { Wx::Locale.set_locale('bad') }
+    locale = Wx::Locale.new(Wx::LANGUAGE_DEFAULT)
+  end
+end
+
+app = TestApp.new
+app.test_class = TestInternationalisation
+app.run

data/tests/test_item_data.rb

@@ -0,0 +1,120 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'wx'
+
+class TestApp < Wx::App
+  attr_accessor :test_class
+  def on_init
+    Test::Unit::UI::Console::TestRunner.run(self.test_class)
+    false
+  end
+end
+
+class CtrlContainerFrame < Wx::Frame
+  attr_accessor :control
+  def initialize(ctrl_class, *args)
+    super(nil, -1, 'Test ' + ctrl_class.name)
+    self.control = ctrl_class.new(self, -1, *args)
+  end
+end
+
+class TestItemData < Test::Unit::TestCase
+  def assert_retrievable_data(ctrl, n, test_value)
+    compare = Marshal.load( Marshal.dump(test_value) )
+    ctrl.set_item_data(n, test_value)
+    assert_equal(compare, ctrl.get_item_data(n) )
+    GC.start
+    assert_equal(compare, ctrl.get_item_data(n) )
+  end
+
+  def do_control_with_items_assertions(f)
+    assert_retrievable_data(f.control, 0, { 'b' => 'B' })
+    assert_retrievable_data(f.control, 1, 'string item data')
+    assert_retrievable_data(f.control, 2, 42.3)
+  end
+
+  def test_treectrl_itemdata
+    f = CtrlContainerFrame.new(Wx::TreeCtrl)
+    tree = f.control
+    root = tree.add_root('foo')
+    assert_nil(tree.get_item_data( tree.get_root_item))
+
+    id = tree.append_item(root, 'a hash', -1, -1, { :a => 7 })
+    assert_equal({:a => 7 }, tree.get_item_data(id) )
+
+    id = tree.prepend_item(root, 'a float', -1, -1, 7.8)
+    assert_equal(7.8, tree.get_item_data(id) )
+    GC.start
+    assert_equal(7.8, tree.get_item_data(id) )
+
+    id = tree.prepend_item(root, 'an array', -1, -1)
+    assert_nil( tree.get_item_data(id) )
+    tree.set_item_data(id, %w|foo bar baz|)
+    assert_equal(%w|foo bar baz|,
+                 f.control.get_item_data(id) )
+    GC.start
+    assert_equal(%w|foo bar baz|,
+                 f.control.get_item_data(id) )
+    f.close(true)
+  end
+
+  def test_listctrl_itemdata
+    f = CtrlContainerFrame.new(Wx::ListCtrl)
+    lc = f.control
+    assert_equal(nil, lc.get_item_data(-7))
+    assert_equal(nil, lc.get_item_data(0))
+    assert_equal(nil, lc.get_item_data(118))
+
+    lc.insert_item(0, 'string')
+    assert_equal(nil, lc.get_item_data(0))
+
+    lc.set_item_data(0, 'a string')
+    assert_equal('a string', lc.get_item_data(0))
+    GC.start
+    assert_equal('a string', lc.get_item_data(0))
+
+    lc.insert_item(1, 'hash')
+    assert_equal(nil, lc.get_item_data(1))
+
+    lc.set_item_data(1, { :a => 457 })
+    assert_equal({ :a => 457 }, lc.get_item_data(1))
+    GC.start
+    assert_equal({ :a => 457 }, lc.get_item_data(1))
+
+    assert_raises(IndexError) { lc.set_item_data(17, 3.412) }
+    f.close(true)
+  end
+
+
+  def test_choice_itemdata
+    f = CtrlContainerFrame.new(Wx::Choice, Wx::DEFAULT_POSITION,
+                                Wx::DEFAULT_SIZE, %w[hash string float])
+    do_control_with_items_assertions(f)
+    f.close(true)
+  end
+
+   def test_listbox_itemdata
+     f = CtrlContainerFrame.new(Wx::ListBox, Wx::DEFAULT_POSITION,
+                                 Wx::DEFAULT_SIZE, %w[hash string float])
+     do_control_with_items_assertions(f)
+     f.close(true)
+   end
+  
+   def test_combobox_itemdata
+     f = CtrlContainerFrame.new(Wx::ComboBox, '', Wx::DEFAULT_POSITION,
+                               Wx::DEFAULT_SIZE, %w[hash string float])
+     do_control_with_items_assertions(f)
+     f.close(true)
+   end
+
+   def test_checklistbox_itemdata
+     f = CtrlContainerFrame.new(Wx::CheckListBox, Wx::DEFAULT_POSITION,
+                                Wx::DEFAULT_SIZE, %w[hash string float])
+     do_control_with_items_assertions(f)
+     f.close(true)
+   end
+end
+
+app = TestApp.new
+app.test_class = TestItemData
+app.run

data/tests/test_variant.rb

@@ -0,0 +1,151 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'wx'
+
+class TestApp < Wx::App
+  attr_accessor :test_class
+  def on_init
+    Test::Unit::UI::Console::TestRunner.run(self.test_class)
+    GC.start
+    false # exit after tests
+  end
+end
+
+class TestVariant < Test::Unit::TestCase
+
+  def test_basics
+    var = Wx::Variant.new('text variant')
+    assert_equal('text variant', var.get_string)
+    var = Wx::Variant.new(true)
+    assert_equal(true, var.get_bool)
+    var = Wx::Variant.new(1234)
+    assert_equal(1234, var.get_long)
+    assert_equal(1234, var.to_i)
+    var = Wx::Variant.new(1234.5678)
+    assert_equal(1234.5678, var.get_double)
+    var = Wx::Variant.new(2**64-1)
+    assert_equal(2**64-1, var.get_u_long_long)
+    assert_equal(2**64-1, var.to_i)
+    var = Wx::Variant.new(1-(2**63))
+    assert_equal(1-(2**63), var.get_long_long)
+    assert_equal(1-(2**63), var.to_i)
+    tm = Time.now
+    var = Wx::Variant.new(tm)
+    assert_equal(tm.round(3), var.get_date_time)
+    assert_equal(tm.round(3).to_i, var.to_i)
+    var = Wx::Variant.new(%w[one two three four])
+    assert_equal(%w[one two three four], var.get_array_string)
+    vars = ['one', 2, true].collect { |o| Wx::Variant.new(o) }
+    var = Wx::Variant.new(vars)
+    assert(var.all? { |v| v == vars.shift })
+  end
+
+  class AClass
+    def initialize(o)
+      @val = o
+    end
+
+    def ==(other)
+      self.class === other && @val == other.instance_variable_get('@val')
+    end
+  end
+
+  def test_ruby_values
+    var = Wx::Variant.new({one: 1, two: 2, three: 3})
+    GC.start
+    assert_equal({one: 1, two: 2, three: 3}, var.get_object)
+    GC.start
+    var = Wx::Variant.new(AClass.new([1,2,3,4]))
+    GC.start
+    assert_equal(AClass.new([1,2,3,4]), var.get_object)
+    GC.start
+  end
+
+  def test_wx_objects
+    font = Wx::Font.new(10, Wx::FONTFAMILY_SWISS, Wx::FONTSTYLE_NORMAL, Wx::FONTWEIGHT_NORMAL)
+    var = Wx::Variant.new(font)
+    GC.start
+    assert_equal(font, var.font)
+    assert_equal(Wx::Font, var.font.class)
+    img = Wx::Image.new
+    var = Wx::Variant.new(img)
+    GC.start
+    assert_equal(img, var.object)
+    assert_equal(Wx::Image, var.object.class)
+    col = Wx::Colour.new('RED')
+    var = Wx::Variant.new(col)
+    GC.start
+    assert_equal(col, var.colour)
+    col = Wx::Colour.new(246, 22, 22)
+    var = Wx::Variant.new(col)
+    GC.start
+    assert_equal(col, var.colour)
+  end
+
+  def test_assign
+    var = Wx::Variant.new('text variant')
+    assert_equal('text variant', var.get_string)
+    var.assign(true)
+    assert_equal(true, var.get_bool)
+    var.assign(1234)
+    assert_equal(1234, var.get_long)
+    var.assign(1234.5678)
+    assert_equal(1234.5678, var.get_double)
+    var.assign(2**64-1)
+    assert_equal(2**64-1, var.get_u_long_long)
+    var.assign(1-(2**63))
+    assert_equal(1-(2**63), var.get_long_long)
+    tm = Time.now
+    var.assign(tm)
+    assert_equal(tm.round(3), var.get_date_time)
+    var.assign(%w[one two three four])
+    assert_equal(%w[one two three four], var.get_array_string)
+    vars = ['one', 2, true].collect { |o| Wx::Variant.new(o) }
+    var.assign(vars)
+    assert(var.all? { |v| v == vars.shift })
+    var << AClass.new([1,2,3,4])
+    assert_equal(AClass.new([1,2,3,4]), var.get_object)
+  end
+
+  def test_to_s
+    var = Wx::Variant.new('text variant')
+    assert_equal('text variant', var.to_s)
+    var = Wx::Variant.new(true)
+    assert_equal(true.to_s, var.to_s)
+    var = Wx::Variant.new(1234)
+    assert_equal((1234).to_s, var.to_s)
+    var = Wx::Variant.new(1234.5678)
+    assert_equal((1234.5678).to_s, var.to_s)
+    var = Wx::Variant.new(2**64-1)
+    assert_equal((2**64-1).to_s, var.to_s)
+    var = Wx::Variant.new(1-(2**63))
+    assert_equal((1-(2**63)).to_s, var.to_s)
+    tm = Time.now
+    var = Wx::Variant.new(tm)
+    assert_equal(tm.round(3).to_s, var.to_s)
+    var = Wx::Variant.new(%w[one two three four])
+    assert_equal(%w[one two three four].to_s, var.to_s)
+    vars = ['one', 2, true].collect { |o| Wx::Variant.new(o) }
+    var = Wx::Variant.new(vars)
+    assert_equal(['one', 2, true].to_s, var.to_s)
+  end
+
+  def test_to_f
+    var = Wx::Variant.new(1234)
+    assert_equal((1234).to_f, var.to_f)
+    var = Wx::Variant.new(1234.5678)
+    assert_equal((1234.5678).to_f, var.to_f)
+    var = Wx::Variant.new(2**64-1)
+    assert_equal((2**64-1).to_f, var.to_f)
+    var = Wx::Variant.new(1-(2**63))
+    assert_equal((1-(2**63)).to_f, var.to_f)
+    tm = Time.now
+    var = Wx::Variant.new(tm)
+    assert_equal(tm.round(3).to_f, var.to_f)
+ end
+
+end
+
+app = TestApp.new
+app.test_class = TestVariant
+app.run

data/tests/testapp.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'wx'
+
+class TestingFrame < Wx::Frame
+    def initialize
+        super(nil, -1, '')
+        evt_paint { on_paint }
+    end
+
+    def on_paint
+        paint {}
+        close
+    end
+end
+
+class AppWithSimpleFrame < Wx::App
+    attr_reader(:did_call_on_exit)
+
+    def on_init
+        TestingFrame.new.show
+    end
+
+    def on_exit
+        @did_call_on_exit = true
+        return 0
+    end
+end
+
+class TestApp < Test::Unit::TestCase
+  def test_self_closing_frame
+    o = AppWithSimpleFrame.new
+    o.run
+    assert(o.did_call_on_exit, "didn't call on_exit?")
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit/ui/console/testrunner'
+  Test::Unit::UI::Console::TestRunner.run(TestApp)
+end

data/tests/testapp_noframe.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'wx'
+
+class AppReturnsFalseFromInit < Wx::App
+    attr_reader :did_call_on_init, :the_app_name
+    
+    def on_init
+        @did_call_on_init = true
+        @the_app_name = self.get_app_name
+        return false
+    end
+    
+end
+
+class TestApp < Test::Unit::TestCase
+  def test_return_false_from_init
+    o = AppReturnsFalseFromInit.new
+    o.run
+    assert(o.did_call_on_init, "didn't call on_init?")
+    assert_equal("wxruby", o.the_app_name)
+  end
+  
+end
+
+if $0 == __FILE__
+  require 'test/unit/ui/console/testrunner'
+  Test::Unit::UI::Console::TestRunner.run(TestApp)
+end