wxruby3 0.9.0.pre.beta.14-x64-mingw-ucrt → 0.9.0.pre.rc.2-x64-mingw-ucrt

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
@@ -89,6 +86,10 @@ class TestInternationalisation < Test::Unit::TestCase
     end
 
     assert_raises(ArgumentError) { Wx::Locale.set_locale('bad') }
-    locale = Wx::Locale.new(Wx::LANGUAGE_DEFAULT)
+    # this causes problems on MacOSX if the language / region combination is unusual
+    # like on my system (US English language / NL region)
+    unless Wx::PLATFORM == 'WXOSX'
+      locale = Wx::Locale.new(Wx::LANGUAGE_DEFAULT)
+    end
   end
 end

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,373 @@
+
+require_relative './lib/wxframe_runner'
+require_relative './lib/text_entry_tests'
+require_relative './lib/item_container_tests'
+
+class ButtonTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @button = Wx::Button.new(test_frame, label: 'Button')
+  end
+
+  def cleanup
+    @button.destroy
+    super
+  end
+
+  attr_reader :button
+
+  if has_ui_simulator?
+
+  def test_click
+    count = count_events(button, :evt_button) do
+      sim = Wx::UIActionSimulator.new
+
+      # We move in to the middle of the widget, we need to yield
+      # after every Wx::UIActionSimulator action to keep everything working in GTK
+      sim.mouse_move(button.get_screen_position + (button.size / 2))
+      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 to the middle of the widget, we need to yield
+      # after every Wx::UIActionSimulator action to keep everything working in GTK
+      sim.mouse_move(button.get_screen_position + (button.size / 2))
+      Wx.get_app.yield
+
+      sim.mouse_click
+      Wx.get_app.yield
+    end
+
+    assert_equal(0, count)
+  end
+
+  end # has_ui_simulator?
+
+  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
+
+  include TextEntryTests
+
+  def setup
+    super
+    @text = Wx::TextCtrl.new(test_frame, name: 'Text')
+  end
+
+  def cleanup
+    @text.destroy
+    super
+  end
+
+  attr_reader :text
+  alias :text_entry :text
+
+  def test_text
+    assert_equal('', text.get_value)
+  end
+
+  if has_ui_simulator?
+  def test_max_length
+    sim = Wx::UIActionSimulator.new
+
+    updates = count_events(text_entry, :evt_text) do |c_upd|
+      maxlen_count = count_events(text_entry, :evt_text_maxlen) do |c_maxlen|
+        # set focus to text_entry text_entry
+        text_entry.set_focus
+        Wx.get_app.yield
+
+        sim.text('Hello')
+        Wx.get_app.yield
+
+        assert_equal('Hello', text_entry.get_value)
+        assert_equal(5, c_upd.count)
+
+        text_entry.set_max_length(10)
+        sim.text('World')
+        Wx.get_app.yield
+
+        assert_equal('HelloWorld', text_entry.get_value)
+        assert_equal(10, c_upd.count)
+        assert_equal(0, c_maxlen.count)
+
+        sim.text('!')
+        Wx.get_app.yield
+
+        assert_equal('HelloWorld', text_entry.get_value)
+        assert_equal(10, c_upd.count)
+        assert_equal(1, c_maxlen.count)
+      end
+    end
+  end
+
+  end # has_ui_simulator?
+
+end
+
+class ComboBoxTests < WxRuby::Test::GUITests
+
+  include TextEntryTests
+
+  def setup
+    super
+    @combo = Wx::ComboBox.new(test_frame, name: 'ComboBox', choices: %w[One Two Three])
+    @combo.clear
+  end
+
+  def cleanup
+    @combo.destroy
+    super
+  end
+
+  attr_reader :combo
+  alias :text_entry :combo
+
+  def test_combo
+    assert_equal('', combo.get_value)
+  end
+
+end
+
+class CheckBoxTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @check = Wx::CheckBox.new(test_frame, label: 'Check Box')
+  end
+
+  def cleanup
+    @check.destroy
+    super
+  end
+
+  def create_checkbox(style)
+    @check.destroy
+    @check = nil
+    @check = Wx::CheckBox.new(test_frame, label: 'Check Box', style: style)
+  end
+
+  attr_reader :check
+
+  def test_check
+    count = count_events(check, :evt_checkbox) do
+      assert(!check.checked?)
+
+      check.set_value(true)
+
+      assert(check.checked?)
+
+      check.set_value(false)
+
+      assert(!check.checked?)
+
+      check.set3state_value(Wx::CheckBoxState::CHK_CHECKED)
+
+      assert(check.checked?)
+
+      check.set3state_value(Wx::CheckBoxState::CHK_UNCHECKED)
+
+      assert(!check.checked?)
+
+    end
+
+    assert_equal(0, count) # should not have emitted any events
+  end
+
+  def test_third_state
+
+    create_checkbox(Wx::CHK_3STATE)
+
+    assert_equal(Wx::CheckBoxState::CHK_UNCHECKED, check.get3state_value)
+    assert(check.is3state)
+    assert(!check.is3rd_state_allowed_for_user)
+
+    check.value = true
+
+    assert_equal(Wx::CheckBoxState::CHK_CHECKED, check.get3state_value)
+
+    check.set3state_value(Wx::CheckBoxState::CHK_UNDETERMINED)
+
+    assert_equal(Wx::CheckBoxState::CHK_UNDETERMINED, check.get3state_value)
+  end
+
+  def test_third_state_user
+
+    create_checkbox(Wx::CHK_3STATE | Wx::CHK_ALLOW_3RD_STATE_FOR_USER)
+
+    assert_equal(Wx::CheckBoxState::CHK_UNCHECKED, check.get3state_value)
+    assert(check.is3state)
+    assert(check.is3rd_state_allowed_for_user)
+
+    check.value = true
+
+    assert_equal(Wx::CheckBoxState::CHK_CHECKED, check.get3state_value)
+
+    check.set3state_value(Wx::CheckBoxState::CHK_UNDETERMINED)
+
+    assert_equal(Wx::CheckBoxState::CHK_UNDETERMINED, check.get3state_value)
+  end
+
+  def test_invalid_style
+
+    # prints assertion warning and creates default checkbox
+    assert_with_assertion_failure { create_checkbox(Wx::CHK_3STATE | Wx::CHK_2STATE) }
+
+  end
+
+end
+
+
+class RadioBoxTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @radiobox = Wx::RadioBox.new(test_frame, label: 'Radio Box', choices: ['item 0', 'item 1', 'item 2'])
+  end
+
+  def cleanup
+    @radiobox.destroy
+    super
+  end
+
+  attr_reader :radiobox
+
+  def test_find_string
+    assert_equal(Wx::NOT_FOUND, radiobox.find_string('Not An Item'))
+    assert_equal(1, radiobox.find_string('item 1'))
+    assert_equal(2, radiobox.find_string('ITEM 2'))
+    assert_equal(Wx::NOT_FOUND, radiobox.find_string('ITEM 2', true))
+  end
+
+  def test_show
+    radiobox.show(false)
+
+    assert(!radiobox.is_item_shown(0))
+
+    radiobox.show_item(1, true)
+
+    assert(!radiobox.is_item_shown(0))
+    assert(radiobox.is_item_shown(1))
+    assert(!radiobox.is_item_shown(2))
+
+    radiobox.show(true)
+
+    assert(radiobox.is_item_shown(0))
+    assert(radiobox.is_item_shown(1))
+    assert(radiobox.is_item_shown(2))
+
+    radiobox.show_item(0, false)
+
+    assert(!radiobox.is_item_shown(0))
+    assert(radiobox.is_item_shown(1))
+    assert(radiobox.is_item_shown(2))
+  end
+
+  def test_selection
+    # by default first item selected
+    assert_equal(0, radiobox.get_selection)
+    assert_equal('item 0', radiobox.get_string_selection)
+
+    radiobox.set_selection(1)
+
+    assert_equal(1, radiobox.get_selection)
+    assert_equal('item 1', radiobox.get_string_selection)
+
+    radiobox.string_selection = 'item 2'
+
+    assert_equal(2, radiobox.selection)
+    assert_equal('item 2', radiobox.string_selection)
+  end
+
+  def test_set_string
+    radiobox.set_string(0, 'new item 0')
+    radiobox.set_string(2, '')
+
+    assert_equal('new item 0', radiobox.get_string(0))
+    assert_equal('', radiobox.string(2))
+  end
+
+  def test_count
+    assert_equal(3, radiobox.get_count)
+    assert(!radiobox.empty?)
+  end
+
+  def test_help_text
+    assert(radiobox.get_item_help_text(1).empty?)
+
+    radiobox.set_item_help_text(1, 'Item 1 Help')
+
+    assert_equal('Item 1 Help', radiobox.get_item_help_text(1))
+
+    radiobox.set_item_help_text(1, '')
+
+    assert(radiobox.get_item_help_text(1).empty?)
+  end
+
+end
+
+class ChoiceTests < WxRuby::Test::GUITests
+
+  include ItemContainerTests
+
+  def setup
+    super
+    @choice = Wx::Choice.new(test_frame, name: 'Choice')
+  end
+
+  def cleanup
+    @choice.destroy
+    super
+  end
+
+  attr_reader :choice
+  alias :container :choice
+
+  def test_choice
+    assert_equal(Wx::NOT_FOUND, choice.get_selection)
+  end
+
+end