wxruby3 0.9.0.pre.rc.1-x64-mingw-ucrt → 0.9.0.pre.rc.2-x64-mingw-ucrt

data/tests/test_font.rb

@@ -0,0 +1,239 @@
+
+require_relative './lib/wxapp_runner'
+
+class FontTests < Test::Unit::TestCase
+
+  def get_test_fonts
+    [
+      Wx::Font.new(Wx::NORMAL_FONT),
+      Wx::Font.new(Wx::SMALL_FONT),
+      Wx::Font.new(Wx::ITALIC_FONT),
+      Wx::Font.new(Wx::SWISS_FONT),
+      Wx::Font.new(5, Wx::FontFamily::FONTFAMILY_TELETYPE, Wx::FontStyle::FONTSTYLE_NORMAL, Wx::FontWeight::FONTWEIGHT_NORMAL)
+    ]
+  end
+
+  def test_size
+    sz_klass = Struct.new(:specified, # Size in points specified in the ctor.
+                          :expected)  # Expected GetPointSize() return value,
+                                      # -1 here means "same as wxNORMAL_FONT".
+    sizes = [
+      sz_klass.new(9,9),
+      sz_klass.new(10, 10),
+      sz_klass.new(11, 11),
+      sz_klass.new(-1, -1),
+      sz_klass.new(70, -1),
+      sz_klass.new(90, 90),
+    ]
+    
+    size_default = Wx::Font.new(Wx::FontInfo.new).get_point_size
+
+    sizes.each do |size|
+        # Note: use the old-style wxFont ctor as wxFontInfo doesn't implement
+        # any compatibility hacks.
+        font = Wx::Font.new(size.specified,
+                            Wx::FONTFAMILY_DEFAULT,
+                            Wx::FONTSTYLE_NORMAL,
+                            Wx::FONTWEIGHT_NORMAL)
+
+        expected = size.expected
+        expected = size_default if expected == -1
+
+        puts "specified = #{size.specified}, expected =  #{size.expected}" unless is_ci_build?
+        assert_equal(expected, font.get_point_size)
+    end
+
+    # Note that the compatibility hacks only apply to the old ctors, the newer
+    # one, taking wxFontInfo, doesn't support them.
+    assert_equal(70, Wx::Font.new(Wx::FontInfo.new(70)).get_point_size)
+    assert_equal(90, Wx::Font.new(Wx::FontInfo.new(90)).get_point_size)
+
+    # assert_equal fractional point sizes as well.
+    font = Wx::Font.new(Wx::FontInfo.new(12.25))
+    assert_equal(12.25,  font.get_fractional_point_size)
+    assert_equal(12, font.get_point_size)
+
+    font = Wx::NORMAL_FONT
+    font.set_fractional_point_size(9.5)
+    assert_equal(9.5, font.get_fractional_point_size)
+    assert_equal(10, font.get_point_size)
+  end
+
+  def test_weight
+    font = Wx::Font.new
+    font.set_numeric_weight(123)
+
+    assert_equal(123, font.get_numeric_weight) unless Wx::PLATFORM == 'WXOSX'
+
+    assert_equal(Wx::FontWeight::FONTWEIGHT_THIN,  font.get_weight)
+
+    font.set_numeric_weight(Wx::FontWeight::FONTWEIGHT_SEMIBOLD)
+    assert_equal(Wx::FontWeight::FONTWEIGHT_SEMIBOLD, font.get_numeric_weight)
+    assert_equal(Wx::FontWeight::FONTWEIGHT_SEMIBOLD, font.get_weight)
+  end
+
+  def test_get_set
+
+    get_test_fonts.each_with_index do |test, n|
+
+      assert(test.ok?)
+
+      # test Get/SetFaceName()
+      assert( !test.set_face_name("a dummy face name") )
+      assert( !test.ok? )
+
+      # if the call to set_face_name() below fails on your system/port,
+      # consider adding another branch to this if
+      known_good_face_name = if Wx::PLATFORM == 'WXMSW' || Wx::PLATFORM == 'WXOSX'
+                               "Arial"
+                             else
+                               "Monospace"
+                             end
+
+      puts("Testing font ##{n}") unless is_ci_build?
+
+      puts("setting face name to #{known_good_face_name}") unless is_ci_build?
+      assert( test.set_face_name(known_good_face_name) )
+      assert( test.ok? )
+
+
+      # test get/set_family()
+
+      test.set_family(Wx::FontFamily::FONTFAMILY_ROMAN )
+      assert( test.ok? )
+
+      # note that there is always the possibility that get_family() returns
+      # Wx::FONTFAMILY_DEFAULT (meaning "unknown" in this case) so that we
+      # consider it as a valid return value
+      family = test.get_family
+      if family != Wx::FONTFAMILY_DEFAULT
+        assert_equal(Wx::FONTFAMILY_ROMAN, family )
+      end
+
+
+      # test get/set_point_size()
+
+      test.set_point_size(30)
+      assert( test.ok? )
+      assert_equal( 30, test.get_point_size )
+
+
+      # test get/set_pixel_size()
+
+      test.set_pixel_size(Wx::Size.new(0,30))
+      assert( test.ok? )
+      assert( test.get_pixel_size.get_height <= 30 )
+        # NOTE: the match found by set_pixel_size() may be not 100% precise it
+        #       only grants that a font smaller than the required height will
+        #       be selected
+
+
+      # test get/set_style()
+
+      test.set_style(Wx::FONTSTYLE_SLANT)
+      assert( test.ok? )
+      # on wxMSW Wx::FONTSTYLE_SLANT==Wx::FONTSTYLE_ITALIC, so accept the latter
+      # as a valid value too.
+      if ( test.get_style != Wx::FONTSTYLE_SLANT )
+        assert( Wx::PLATFORM == 'WXMSW' && Wx::FONTSTYLE_ITALIC == test.get_style )
+      end
+
+      # test get/set_underlined()
+
+      test.set_underlined(true)
+      assert( test.ok? )
+      assert( test.get_underlined )
+
+      fontBase = test.get_base_font
+      assert( fontBase.ok? )
+      assert( !fontBase.get_underlined )
+      assert( !fontBase.get_strikethrough )
+      assert_equal( Wx::FONTWEIGHT_NORMAL, fontBase.get_weight )
+      assert_equal( Wx::FONTSTYLE_NORMAL, fontBase.get_style )
+
+      # test get/set_strikethrough()
+
+      test.set_strikethrough(true)
+      assert( test.ok? )
+      assert( test.get_strikethrough )
+
+
+      # test get/set_weight()
+
+      test.set_weight(Wx::FONTWEIGHT_BOLD)
+      assert( test.ok? )
+      assert_equal( Wx::FONTWEIGHT_BOLD, test.get_weight )
+    end
+
+  end
+
+  def test_native_font_info
+    get_test_fonts.each_with_index do |test, n|
+        nid = test.get_native_font_info_desc
+        assert( !nid.empty? )
+        # documented to be never empty
+
+        temp = Wx::Font.new
+        assert( temp.set_native_font_info(nid) )
+        assert( temp.ok? )
+
+        puts("Testing font ##{n}") unless is_ci_build?
+        puts("original font user description: #{test.get_native_font_info_user_desc}") unless is_ci_build?
+        puts("the other font description: #{temp.get_native_font_info_user_desc}") unless is_ci_build?
+
+        assert_equal( temp, test ) unless Wx::PLATFORM == 'WXOSX'
+    end
+
+    # test that clearly invalid font info strings do not work
+    font = Wx::Font.new
+    assert( !font.set_native_font_info('') )
+
+    # pango_font_description_from_string() used by Wx::Font in wxGTK and wxX11
+    # never returns an error at all so this assertion fails there -- and as it
+    # doesn't seem to be possible to do anything about it maybe we should
+    # change wxMSW and other ports to also accept any strings?
+    unless %w[WXGTK WXX11 WXQT].include?(Wx::PLATFORM)
+    assert( !font.set_native_font_info("bloordyblop") )
+    end
+
+    font.set_underlined(true)
+    font.set_strikethrough(true)
+    assert(font == Wx::Font.new(font))
+    assert(font == Wx::Font.new(font.get_native_font_info_desc)) unless Wx::PLATFORM == 'WXOSX'
+    assert(Wx::Font.new(font.get_native_font_info_desc).get_underlined)
+    assert(Wx::Font.new(font.get_native_font_info_desc).get_strikethrough)
+    font.set_underlined(false)
+    assert(font == Wx::Font.new(font))
+    assert(font == Wx::Font.new(font.get_native_font_info_desc)) unless Wx::PLATFORM == 'WXOSX'
+    assert(!Wx::Font.new(font.get_native_font_info_desc).get_underlined)
+    font.set_underlined(true)
+    font.set_strikethrough(false)
+    assert(font == Wx::Font.new(font))
+    assert(font == Wx::Font.new(font.get_native_font_info_desc)) unless Wx::PLATFORM == 'WXOSX'
+    assert(Wx::Font.new(font.get_native_font_info_desc).get_underlined)
+    assert(!Wx::Font.new(font.get_native_font_info_desc).get_strikethrough)
+  end
+
+  def test_find_or_create
+    [10.5, Wx::Size.new(0, 32)].each do |pt_sz|
+      info = Wx::FontInfo.new(pt_sz)
+
+      font1 = Wx::Font.find_or_create_font(info)
+      assert(font1)
+      assert(font1.ok?)
+
+      puts "Font from font list: #{font1.get_native_font_info_user_desc}" unless is_ci_build?
+
+      if pt_sz.is_a?(Wx::Size)
+        assert(pt_sz.y >= font1.get_pixel_size.y)
+      else
+        assert_equal(pt_sz, font1.get_fractional_point_size) unless is_ci_build?
+      end
+
+      # font 2 should be font1 from the font list "cache"
+      font2 = Wx::TheFontList.find_or_create_font(info)
+      assert_equal(font1, font2)
+    end
+  end
+
+end

data/tests/test_intl.rb

@@ -86,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_std_controls.rb

@@ -1,31 +1,31 @@
 
 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, name: 'Button')
-    Wx.get_app.yield
+    @button = Wx::Button.new(test_frame, label: 'Button')
   end
 
   def cleanup
     @button.destroy
-    Wx.get_app.yield
     super
   end
 
   attr_reader :button
 
-  if Wx.has_feature?(:USE_UIACTIONSIMULATOR)
+  if has_ui_simulator?
 
   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
+      # 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 + Wx::Point.new(10, 10))
+      sim.mouse_move(button.get_screen_position + (button.size / 2))
       Wx.get_app.yield
 
       sim.mouse_click
@@ -40,9 +40,9 @@ class ButtonTests < WxRuby::Test::GUITests
     count = count_events(button, :evt_button) do
       sim = Wx::UIActionSimulator.new
 
-      # We move in slightly to account for window decorations, we need to yield
+      # 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 + Wx::Point.new(10, 10))
+      sim.mouse_move(button.get_screen_position + (button.size / 2))
       Wx.get_app.yield
 
       sim.mouse_click
@@ -52,7 +52,7 @@ class ButtonTests < WxRuby::Test::GUITests
     assert_equal(0, count)
   end
 
-  end # wxUSE_UIACTIONSIMULATOR
+  end # has_ui_simulator?
 
   def test_bitmap
     # We start with no bitmaps
@@ -91,57 +91,283 @@ end
 
 class TextCtrlTests < WxRuby::Test::GUITests
 
+  include TextEntryTests
+
   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
+  alias :text_entry :text
 
+  def test_text
+    assert_equal('', text.get_value)
+  end
 
-  if Wx.has_feature?(:USE_UIACTIONSIMULATOR)
-
-    def test_text
-      assert_equal('', text.get_value)
-      sim = Wx::UIActionSimulator.new
+  if has_ui_simulator?
+  def test_max_length
+    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
+    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
+        sim.text('Hello')
+        Wx.get_app.yield
 
-          assert_equal('Hello', text.get_value)
-          assert_equal(5, c_upd.count)
+        assert_equal('Hello', text_entry.get_value)
+        assert_equal(5, c_upd.count)
 
-          text.set_max_length(10)
-          sim.text('World')
-          Wx.get_app.yield
+        text_entry.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)
+        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
+        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
+        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