wxruby3 0.9.0.pre.beta.13-x64-mingw-ucrt → 0.9.0.pre.rc.1-x64-mingw-ucrt

data/tests/test_event_handling.rb

@@ -41,6 +41,7 @@ class EventHandlingTests < Test::Unit::TestCase
       @child = Child.new(self)
       @test_event = false
       @test_cmd_event = false
+      @called_after = false
 
       evt_test_event { |evt| @test_event = true }
       evt_test_cmd_event { |evt| @test_cmd_event = true }
@@ -48,45 +49,227 @@ class EventHandlingTests < Test::Unit::TestCase
 
     attr_reader :child
     attr_reader :test_event, :test_cmd_event
+    attr_accessor :called_after
 
     def reset
       @test_event = false
       @test_cmd_event = false
+      @called_after = false
       child.reset
     end
   end
 
   def test_event
     win = TestFrame.new
-    assert_boolean(!win.test_event)
-    assert_boolean(!win.child.test_event)
+    assert(!win.test_event)
+    assert(!win.child.test_event)
     win.child.event_handler.process_event(TestEvent.new)
-    assert_boolean(!win.test_event)
-    assert_boolean(win.child.test_event)
+    assert(!win.test_event)
+    assert(win.child.test_event)
     win.reset
     win.child.event_handler.process_event(TestEvent.new(1))
-    assert_boolean(!win.test_event)
-    assert_boolean(win.child.test_event)
+    assert(!win.test_event)
+    assert(win.child.test_event)
     win.reset
     win.event_handler.process_event(TestEvent.new)
-    assert_boolean(win.test_event)
-    assert_boolean(!win.child.test_event)
+    assert(win.test_event)
+    assert(!win.child.test_event)
+    win.destroy
+    Wx.get_app.yield
   end
 
   def test_cmd_event
     win = TestFrame.new
-    assert_boolean(!win.test_cmd_event)
-    assert_boolean(!win.child.test_cmd_event)
+    assert(!win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
     win.child.event_handler.process_event(TestCmdEvent.new)
-    assert_boolean(!win.test_cmd_event)
-    assert_boolean(win.child.test_cmd_event)
+    assert(!win.test_cmd_event)
+    assert(win.child.test_cmd_event)
     win.reset
     win.child.event_handler.process_event(TestCmdEvent.new(1))
-    assert_boolean(win.test_cmd_event)
-    assert_boolean(win.child.test_cmd_event)
+    assert(win.test_cmd_event)
+    assert(win.child.test_cmd_event)
     win.reset
     win.event_handler.process_event(TestCmdEvent.new)
-    assert_boolean(win.test_cmd_event)
-    assert_boolean(!win.child.test_cmd_event)
+    assert(win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
+    win.destroy
+    Wx.get_app.yield
   end
+
+  def test_queue_event
+    win = TestFrame.new
+    assert(!win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
+    win.child.event_handler.queue_event(TestCmdEvent.new)
+    Wx.get_app.yield
+    assert(!win.test_cmd_event)
+    assert(win.child.test_cmd_event)
+    win.reset
+    win.child.event_handler.queue_event(TestCmdEvent.new(1))
+    Wx.get_app.yield
+    assert(win.test_cmd_event)
+    assert(win.child.test_cmd_event)
+    win.reset
+    win.event_handler.queue_event(TestCmdEvent.new)
+    Wx.get_app.yield
+    assert(win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
+    win.destroy
+    Wx.get_app.yield
+  end
+
+  def test_pending_event
+    win = TestFrame.new
+    assert(!win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
+    win.child.event_handler.add_pending_event(TestCmdEvent.new)
+    Wx.get_app.yield
+    assert(!win.test_cmd_event)
+    assert(win.child.test_cmd_event)
+    win.reset
+    win.child.event_handler.add_pending_event(TestCmdEvent.new(1))
+    Wx.get_app.yield
+    assert(win.test_cmd_event)
+    assert(win.child.test_cmd_event)
+    win.reset
+    win.event_handler.add_pending_event(TestCmdEvent.new)
+    Wx.get_app.yield
+    assert(win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
+    win.destroy
+    Wx.get_app.yield
+  end
+
+  def test_post_event
+    win = TestFrame.new
+    assert(!win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
+    Wx.post_event(win.child.event_handler, TestCmdEvent.new)
+    Wx.get_app.yield
+    assert(!win.test_cmd_event)
+    assert(win.child.test_cmd_event)
+    win.reset
+    Wx.post_event(win.child.event_handler, TestCmdEvent.new(1))
+    Wx.get_app.yield
+    assert(win.test_cmd_event)
+    assert(win.child.test_cmd_event)
+    win.reset
+    Wx.post_event(win.event_handler, TestCmdEvent.new)
+    Wx.get_app.yield
+    assert(win.test_cmd_event)
+    assert(!win.child.test_cmd_event)
+    win.destroy
+    Wx.get_app.yield
+  end
+
+  def test_call_after
+    win = TestFrame.new
+    assert(!win.called_after)
+    win.event_handler.call_after { win.called_after = true }
+    Wx.get_app.yield
+    assert(win.called_after)
+    win.reset
+    win.child.event_handler.call_after { win.called_after = true }
+    Wx.get_app.yield
+    assert(win.called_after)
+    win.destroy
+    Wx.get_app.yield
+  end
+
+  def test_event_blocker
+    win = TestFrame.new
+    assert(!win.test_event)
+    win.event_handler.process_event(TestEvent.new)
+    assert(win.test_event)
+    win.reset
+    Wx::EventBlocker.blocked_for(win) do |blkr|
+      win.event_handler.process_event(TestEvent.new(1))
+    end
+    assert(!win.test_event)
+    win.event_handler.process_event(TestEvent.new)
+    assert(win.test_event)
+    win.reset
+    Wx::EventBlocker.blocked_for(win, TestEvent::EVT_TEST_EVENT) do |blkr|
+      win.event_handler.process_event(TestEvent.new(1))
+    end
+    assert(!win.test_event)
+    win.event_handler.process_event(TestEvent.new)
+    assert(win.test_event)
+    win.reset
+    Wx::EventBlocker.blocked_for(win, Wx::EVT_ACTIVATE) do |blkr|
+      win.event_handler.process_event(TestEvent.new(1))
+    end
+    assert(win.test_event)
+    win.destroy
+    Wx.get_app.yield
+  end
+
+  class MyEventFilter < Wx::EventFilter
+    def initialize
+      super
+      @filtered = false
+    end
+
+    attr_accessor :filtered
+
+    def filter_event(event)
+      @filtered = true if event.is_a?(TestEvent)
+      Wx::EventFilter::Event_Skip
+    end
+  end
+
+  def test_event_filter
+    filter = MyEventFilter.new
+    assert_nothing_raised { Wx::EvtHandler.add_filter(filter) }
+    GC.start
+    win = TestFrame.new
+    win.child.event_handler.process_event(TestEvent.new)
+    GC.start
+    assert(filter.filtered)
+    filter.filtered = false
+    win.child.event_handler.process_event(TestCmdEvent.new)
+    GC.start
+    assert(!filter.filtered)
+    assert_nothing_raised { Wx::EvtHandler.remove_filter(filter) }
+    GC.start
+    win.child.event_handler.process_event(TestEvent.new)
+    assert(!filter.filtered)
+    GC.start
+    win.destroy
+    Wx.get_app.yield
+  end
+
+  class MyEventFilter2 < Wx::EventFilter
+
+    class << self
+      attr_accessor :filtered
+    end
+
+    def filter_event(event)
+      MyEventFilter2.filtered = true if event.is_a?(TestEvent)
+      Wx::EventFilter::Event_Skip
+    end
+  end
+
+  def test_event_filter_clear
+    assert_nothing_raised { Wx::EvtHandler.add_filter(MyEventFilter2.new) }
+    GC.start
+    win = TestFrame.new
+    win.child.event_handler.process_event(TestEvent.new)
+    GC.start
+    assert(MyEventFilter2.filtered)
+    MyEventFilter2.filtered = false
+    win.child.event_handler.process_event(TestCmdEvent.new)
+    GC.start
+    assert(!MyEventFilter2.filtered)
+    assert_nothing_raised { Wx::EvtHandler.clear_filters }
+    GC.start
+    win.child.event_handler.process_event(TestEvent.new)
+    assert(!MyEventFilter2.filtered)
+    GC.start
+    win.destroy
+    Wx.get_app.yield
+  end
+
 end

data/tests/test_events.rb

@@ -7,9 +7,9 @@ class EventTests < Test::Unit::TestCase
     evt = Wx::Event.new(100, 1)
     assert_equal(100, evt.event_type)
     assert_equal(1, evt.id)
-    assert_boolean(!evt.should_propagate)
+    assert(!evt.should_propagate)
     evt.skip
-    assert_boolean(evt.skipped)
+    assert(evt.skipped)
     evt_dup = evt.clone
     assert_not_equal(evt, evt_dup)
     assert_equal(evt.event_type, evt_dup.event_type)
@@ -20,9 +20,9 @@ class EventTests < Test::Unit::TestCase
     evt = Wx::CommandEvent.new(100, 1)
     assert_equal(100, evt.event_type)
     assert_equal(1, evt.id)
-    assert_boolean(evt.should_propagate)
+    assert(evt.should_propagate)
     evt.skip
-    assert_boolean(evt.skipped)
+    assert(evt.skipped)
     evt.string = 'CommandEvent Test'
     assert_equal('CommandEvent Test', evt.string)
     evt_dup = evt.clone
@@ -44,10 +44,3 @@ class EventTests < Test::Unit::TestCase
     assert_equal(evt.position, evt_dup.position)
   end
 end
-
-class TestApp < Wx::App
-  def on_init
-    Test::Unit::UI::Console::TestRunner.run(EventTests)
-    false
-  end
-end

data/tests/test_gdi_object.rb

@@ -0,0 +1,161 @@
+
+require_relative './lib/wxapp_runner'
+
+class TestGDIObjects < Test::Unit::TestCase
+
+  def test_icon
+    ico = Wx::Icon(:sample3)
+    assert(ico.ok?)
+    frame = Wx::Frame.new(nil)
+    frame.set_icon(ico)
+    GC.start
+    ico_cpy = frame.get_icon
+    GC.start
+    assert(ico_cpy.ok?)
+    assert_not_equal(ico.object_id, ico_cpy.object_id)
+    ico = nil
+    ico_cpy = nil
+    GC.start
+    ico_cpy = frame.get_icon
+    GC.start
+    assert(ico_cpy.ok?)
+    assert_not_equal(ico.object_id, ico_cpy.object_id)
+  end
+
+  def test_icon_bundle
+    ib = Wx::IconBundle.new
+    ib.add_icon(Wx::Icon(:sample3))
+    img = Wx::Image(:sample3)
+    ib.add_icon(Wx::Icon.from_bitmap(img.scale(img.get_size.width*2, img.get_size.height*2).to_bitmap))
+    assert_equal(2, ib.get_icon_count)
+    frame = Wx::Frame.new(nil)
+    frame.set_icons(ib)
+    GC.start
+    ib_cpy = frame.get_icons
+    GC.start
+    assert_equal(2, ib_cpy.get_icon_count)
+    assert_not_equal(ib.object_id, ib_cpy.object_id)
+    ib = nil
+    ib_cpy = nil
+    GC.start
+    ib_cpy = frame.get_icons
+    GC.start
+    assert_equal(2, ib_cpy.get_icon_count)
+    assert_not_equal(ib.object_id, ib_cpy.object_id)
+  end
+
+  def test_bitmap_bundle
+    bb = Wx::BitmapBundle.from_bitmaps(Wx::Bitmap(:sample3), Wx::Bitmap.new(Wx::ArtLocator.find_art(:sample, art_section: 'my_art')))
+    assert(bb.ok?)
+    mi = Wx::MenuItem.new(nil, 1, 'test')
+    mi.set_bitmap(bb)
+    GC.start
+    bb_cpy = mi.get_bitmap_bundle
+    GC.start
+    assert(bb_cpy.ok?)
+    assert_not_equal(bb.object_id, bb_cpy.object_id)
+    bb = nil
+    bb_cpy = nil
+    GC.start
+    bb_cpy = mi.get_bitmap_bundle
+    GC.start
+    assert(bb_cpy.ok?)
+    assert_not_equal(bb.object_id, bb_cpy.object_id)
+  end
+
+  def test_bitmap
+    bmp = Wx::Bitmap(:sample3)
+    assert(bmp.ok?)
+    mi = Wx::MenuItem.new(nil, 1, 'test')
+    mi.set_bitmap(bmp)
+    GC.start
+    bmp_cpy = mi.get_bitmap
+    GC.start
+    assert(bmp_cpy.ok?)
+    assert_not_equal(bmp.object_id, bmp_cpy.object_id)
+    bmp = nil
+    bmp_cpy = nil
+    GC.start
+    bmp_cpy = mi.get_bitmap
+    GC.start
+    assert(bmp_cpy.ok?)
+    assert_not_equal(bmp.object_id, bmp_cpy.object_id)
+  end
+
+  def test_colour
+    col = Wx::Colour.new('red')
+    assert(col.ok?)
+    Wx::MemoryDC.draw_on(Wx::Bitmap.new(600, 400)) do |dc|
+      dc.set_text_background(col)
+      GC.start
+      col_cpy = dc.get_text_background
+      GC.start
+      assert(col_cpy.ok?)
+      assert_not_equal(col.object_id, col_cpy.object_id)
+      col = col_cpy = nil
+      GC.start
+      col_cpy = dc.get_text_background
+      GC.start
+      assert(col_cpy.ok?)
+      assert_not_equal(col.object_id, col_cpy.object_id)
+    end
+  end
+
+  def test_font
+    font = Wx::Font.new(10, Wx::FontFamily::FONTFAMILY_DEFAULT, Wx::FontStyle::FONTSTYLE_NORMAL, Wx::FontWeight::FONTWEIGHT_BOLD)
+    assert(font.ok?)
+    Wx::MemoryDC.draw_on(Wx::Bitmap.new(600, 400)) do |dc|
+      dc.set_font(font)
+      GC.start
+      font_cpy = dc.get_font
+      GC.start
+      assert(font_cpy.ok?)
+      assert_not_equal(font.object_id, font_cpy.object_id)
+      font = font_cpy = nil
+      GC.start
+      font_cpy = dc.get_font
+      GC.start
+      assert(font_cpy.ok?)
+      assert_not_equal(font.object_id, font_cpy.object_id)
+    end
+  end
+
+  def test_brush
+    brush = Wx::Brush.new(:black)
+    assert(brush.ok?)
+    Wx::MemoryDC.draw_on(Wx::Bitmap.new(600, 400)) do |dc|
+      dc.set_brush(brush)
+      GC.start
+      brush_cpy = dc.get_brush
+      GC.start
+      assert(brush_cpy.ok?)
+      assert_not_equal(brush.object_id, brush_cpy.object_id)
+      brush = brush_cpy = nil
+      GC.start
+      brush_cpy = dc.get_brush
+      GC.start
+      assert(brush_cpy.ok?)
+      assert_not_equal(brush.object_id, brush_cpy.object_id)
+    end
+  end
+
+  def test_pen
+    pen = Wx::Pen.new(:black, 1, Wx::PenStyle::PENSTYLE_SOLID)
+    assert(pen.ok?)
+    Wx::MemoryDC.draw_on(Wx::Bitmap.new(600, 400)) do |dc|
+      dc.set_pen(pen)
+      GC.start
+      pen_cpy = dc.get_pen
+      GC.start
+      assert(pen_cpy.ok?)
+      assert_not_equal(pen.object_id, pen_cpy.object_id)
+      pen = pen_cpy = nil
+      GC.start
+      pen_cpy = dc.get_pen
+      GC.start
+      assert(pen_cpy.ok?)
+      assert_not_equal(pen.object_id, pen_cpy.object_id)
+    end
+  end
+
+end

data/tests/test_intl.rb

@@ -35,20 +35,17 @@ class TestInternationalisation < Test::Unit::TestCase
     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_add_language_info
+    new_lang_info = Wx::LanguageInfo.new
+    new_lang_info.canonical_name = 'ma_MA'
+    new_lang_info.description = 'Marain'
+    new_lang_info.language = 1000
+    Wx::Locale.add_language(new_lang_info)
+    lang_info = Wx::Locale.find_language_info('ma_MA')
+    assert_equal(1000, 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

data/tests/test_item_data.rb

@@ -91,6 +91,31 @@ class TestItemData < Test::Unit::TestCase
     GC.start
   end
 
+  def do_sorted_control_with_items_assertions(f)
+    f.control.append(%w[Beta Alpha Gamma Delta], [1, 'a', :sym, true])
+    assert_equal(4, f.control.count)
+    assert_equal('a', f.control.get_item_data(0))
+    assert_equal(1, f.control.get_item_data(1))
+    assert_equal(true, f.control.get_item_data(2))
+    assert_equal(:sym, f.control.get_item_data(3))
+    GC.start
+    assert_equal('a', f.control.get_client_data(0))
+    assert_equal(1, f.control.get_client_data(1))
+    assert_equal(true, f.control.get_client_data(2))
+    assert_equal(:sym, f.control.get_client_data(3))
+    GC.start
+    f.control.delete(2)
+    GC.start
+    assert_equal(3, f.control.count)
+    assert_equal('a', f.control.get_item_data(0))
+    assert_equal(1, f.control.get_item_data(1))
+    assert_equal(:sym, f.control.get_item_data(2))
+    GC.start
+    assert_equal('a', f.control.get_client_data(0))
+    assert_equal(1, f.control.get_client_data(1))
+    assert_equal(:sym, f.control.get_client_data(2))
+  end
+
   def test_treectrl_itemdata
     f = CtrlContainerFrame.new(Wx::TreeCtrl)
     tree = f.control
@@ -157,7 +182,14 @@ class TestItemData < Test::Unit::TestCase
      do_control_with_items_assertions(f)
      f.close(true)
    end
-  
+
+  def test_sorted_listbox_itemdata
+    f = CtrlContainerFrame.new(Wx::ListBox, Wx::DEFAULT_POSITION,
+                               Wx::DEFAULT_SIZE, [], Wx::LB_SORT)
+    do_sorted_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])

data/tests/test_std_controls.rb

@@ -0,0 +1,147 @@
+
+require_relative './lib/wxframe_runner'
+
+class ButtonTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @button = Wx::Button.new(test_frame, name: 'Button')
+    Wx.get_app.yield
+  end
+
+  def cleanup
+    @button.destroy
+    Wx.get_app.yield
+    super
+  end
+
+  attr_reader :button
+
+  if Wx.has_feature?(:USE_UIACTIONSIMULATOR)
+
+  def test_click
+    count = count_events(button, :evt_button) do
+      sim = Wx::UIActionSimulator.new
+
+      # We move in slightly to account for window decorations, we need to yield
+      # after every Wx::UIActionSimulator action to keep everything working in GTK
+      sim.mouse_move(button.get_screen_position + Wx::Point.new(10, 10))
+      Wx.get_app.yield
+
+      sim.mouse_click
+      Wx.get_app.yield
+    end
+
+    assert_equal(1, count)
+  end
+
+  def test_disabled
+    button.disable
+    count = count_events(button, :evt_button) do
+      sim = Wx::UIActionSimulator.new
+
+      # We move in slightly to account for window decorations, we need to yield
+      # after every Wx::UIActionSimulator action to keep everything working in GTK
+      sim.mouse_move(button.get_screen_position + Wx::Point.new(10, 10))
+      Wx.get_app.yield
+
+      sim.mouse_click
+      Wx.get_app.yield
+    end
+
+    assert_equal(0, count)
+  end
+
+  end # wxUSE_UIACTIONSIMULATOR
+
+  def test_bitmap
+    # We start with no bitmaps
+    assert(!button.get_bitmap.ok?)
+
+    # Some bitmap, doesn't really matter which.
+    bmp = Wx::ArtProvider.get_bitmap(Wx::ART_INFORMATION)
+
+    button.set_bitmap(bmp)
+
+    assert(button.get_bitmap.ok?)
+
+    # The call above shouldn't affect any other bitmaps as returned by the API
+    # even though the same (normal) bitmap does appear for all the states.
+    assert( !button.get_bitmap_current.ok? )
+    assert( !button.get_bitmap_disabled.ok? )
+    assert( !button.get_bitmap_focus.ok? )
+    assert( !button.get_bitmap_pressed.ok? )
+
+    # Do set one of the bitmaps now.
+    button.set_bitmap_pressed(Wx::ArtProvider.get_bitmap(Wx::ART_ERROR))
+    assert( button.get_bitmap_pressed.ok? )
+
+    # Check that resetting the button label doesn't result in problems when
+    # updating the bitmap later, as it used to be the case in wxGTK (#18898).
+    button.set_label('')
+    assert_nothing_raised { button.disable }
+
+    # Also check that setting an invalid bitmap doesn't do anything untoward,
+    # such as crashing, as it used to do in wxOSX (#19257).
+    assert_nothing_raised { button.set_bitmap_pressed(Wx::NULL_BITMAP) }
+    assert( !button.get_bitmap_pressed.ok? )
+  end
+
+end
+
+class TextCtrlTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @text = Wx::TextCtrl.new(test_frame, name: 'Text')
+    Wx.get_app.yield
+  end
+
+  def cleanup
+    @text.destroy
+    Wx.get_app.yield
+    super
+  end
+
+  attr_reader :text
+
+
+  if Wx.has_feature?(:USE_UIACTIONSIMULATOR)
+
+    def test_text
+      assert_equal('', text.get_value)
+      sim = Wx::UIActionSimulator.new
+
+      updates = count_events(text, :evt_text) do |c_upd|
+        maxlen_count = count_events(text, :evt_text_maxlen) do |c_maxlen|
+          # set focus to text control
+          text.set_focus
+          Wx.get_app.yield
+
+          sim.text('Hello')
+          Wx.get_app.yield
+
+          assert_equal('Hello', text.get_value)
+          assert_equal(5, c_upd.count)
+
+          text.set_max_length(10)
+          sim.text('World')
+          Wx.get_app.yield
+
+          assert_equal('HelloWorld', text.get_value)
+          assert_equal(10, c_upd.count)
+          assert_equal(0, c_maxlen.count)
+
+          sim.text('!')
+          Wx.get_app.yield
+
+          assert_equal('HelloWorld', text.get_value)
+          assert_equal(10, c_upd.count)
+          assert_equal(1, c_maxlen.count)
+        end
+      end
+    end
+
+  end
+
+end