wxruby3 0.9.0.pre.rc.1-x64-mingw-ucrt → 0.9.0.pre.rc.3-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_grid_sizer.rb

@@ -0,0 +1,148 @@
+
+require_relative './lib/wxframe_runner'
+
+class GridSizerTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @win = Wx::Window.new(test_frame, Wx::ID_ANY)
+    @win.set_client_size(127, 35)
+    @sizer = Wx::GridSizer.new(2)
+    @win.set_sizer(@sizer)
+  end
+
+  def cleanup
+    test_frame.destroy_children
+    @win = nil
+    @sizer = nil
+    super
+  end
+
+  attr_reader :win, :sizer
+
+  def set_children(children, flags)
+    @sizer.clear
+    children.each { |c| @sizer.add(c, flags) }
+    @win.layout
+  end
+
+  def test_layout
+    sizeTotal = win.get_client_size
+    sizeChild = Wx::Size.new(sizeTotal.x / 2, sizeTotal.y / 2)
+
+    children = [Wx::Window.new(win, Wx::ID_ANY),
+                Wx::Window.new(win, Wx::ID_ANY),
+                Wx::Window.new(win, Wx::ID_ANY)]
+
+    set_children(children, Wx::SizerFlags.new.expand)
+    assert(children[0].rect == Wx::Rect.new(Wx::Point.new(0, 0), sizeChild))
+    assert(children[1].rect == Wx::Rect.new(Wx::Point.new(sizeChild.x, 0), sizeChild))
+    assert(children[2].rect == Wx::Rect.new(Wx::Point.new(0, sizeChild.y), sizeChild))
+  end
+
+end
+
+class FlexGridSizerTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @win = Wx::Window.new(test_frame, Wx::ID_ANY)
+    @win.set_client_size(127, 35)
+    @sizer = Wx::FlexGridSizer.new(2)
+    @win.set_sizer(@sizer)
+  end
+
+  def cleanup
+    test_frame.destroy_children
+    @win = nil
+    @sizer = nil
+    super
+  end
+
+  attr_reader :win, :sizer
+
+  def set_children(children, flags)
+    @sizer.clear
+    children.each { |c| @sizer.add(c, flags) }
+    @win.layout
+  end
+
+  def do_test_layout
+    sizeTotal = win.get_client_size
+    sizeChild = Wx::Size.new(sizeTotal.x / 4, sizeTotal.y / 4)
+    sizeRest = Wx::Size.new(sizeTotal.x - sizeTotal.x / 4,
+                            sizeTotal.y - sizeTotal.y / 4)
+
+    children = [Wx::Window.new(win, Wx::ID_ANY, Wx::DEFAULT_POSITION, sizeChild),
+                Wx::Window.new(win, Wx::ID_ANY, Wx::DEFAULT_POSITION, sizeChild),
+                Wx::Window.new(win, Wx::ID_ANY, Wx::DEFAULT_POSITION, sizeChild),
+                Wx::Window.new(win, Wx::ID_ANY, Wx::DEFAULT_POSITION, sizeChild)]
+
+    sizer.add_growable_row(1)
+    sizer.add_growable_col(1)
+
+    yield(children, sizeTotal, sizeChild, sizeRest)
+  end
+
+  def test_layout
+    do_test_layout do |children, sizeTotal, sizeChild, sizeRest|
+      set_children(children, Wx::SizerFlags.new)
+      assert_equal( sizeChild, children[0].get_size)
+      assert_equal( sizeChild, children[1].get_size )
+      assert_equal( sizeChild, children[2].get_size )
+      assert_equal( sizeChild, children[3].get_size )
+    end
+  end
+
+  def test_layout_expand
+    do_test_layout do |children, sizeTotal, sizeChild, sizeRest|
+      set_children(children, Wx::SizerFlags.new.expand)
+      assert_equal(sizeChild, children[0].get_size)
+      assert_equal(Wx::Size.new(sizeRest.x, sizeChild.y), children[1].get_size)
+      assert_equal(Wx::Size.new(sizeChild.x, sizeRest.y), children[2].get_size)
+      assert_equal(sizeRest, children[3].get_size )
+    end
+  end
+
+  def test_layout_expand_centre_vertical
+    do_test_layout do |children, sizeTotal, sizeChild, sizeRest|
+      set_children(children, Wx::SizerFlags.new.expand.centre_vertical)
+      assert_equal(sizeChild, children[0].get_size)
+      assert_equal(Wx::Size.new(sizeRest.x, sizeChild.y), children[1].get_size)
+      assert_equal(sizeChild, children[2].get_size )
+      assert_equal(Wx::Size.new(sizeRest.x, sizeChild.y), children[3].get_size)
+    end
+  end
+
+  def test_layout_expand_centre_horizontal
+    do_test_layout do |children, sizeTotal, sizeChild, sizeRest|
+      set_children(children, Wx::SizerFlags.new.expand.centre_horizontal)
+      assert_equal(sizeChild, children[0].get_size)
+      assert_equal(sizeChild, children[1].get_size )
+      assert_equal(Wx::Size.new(sizeChild.x, sizeRest.y), children[2].get_size)
+      assert_equal(Wx::Size.new(sizeChild.x, sizeRest.y), children[3].get_size)
+    end
+  end
+
+  def test_layout_right
+    do_test_layout do |children, sizeTotal, sizeChild, sizeRest|
+      set_children(children, Wx::SizerFlags.new.right)
+      assert_equal( Wx::Point.new(0, 0), children[0].get_position)
+      assert_equal( Wx::Point.new(sizeRest.x, 0), children[1].get_position)
+      assert_equal( Wx::Point.new(0, sizeChild.y), children[2].get_position)
+      assert_equal( Wx::Point.new(sizeRest.x, sizeChild.y), children[3].get_position)
+    end
+  end
+
+  def test_layout_right_centre_vertical
+    do_test_layout do |children, sizeTotal, sizeChild, sizeRest|
+      set_children(children, Wx::SizerFlags.new.right.centre_vertical)
+      yMid = sizeChild.y + (sizeRest.y - sizeChild.y) / 2
+      assert_equal( Wx::Point.new(0, 0), children[0].get_position)
+      assert_equal( Wx::Point.new(sizeRest.x, 0), children[1].get_position)
+      assert_equal( Wx::Point.new(0, yMid), children[2].get_position)
+      assert_equal( Wx::Point.new(sizeRest.x, yMid), children[3].get_position)
+    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_list_ctrl.rb

@@ -0,0 +1,53 @@
+
+require_relative './lib/wxframe_runner'
+
+class ButtonTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @list = Wx::ListCtrl.new(test_frame)
+    @list.set_window_style(Wx::LC_REPORT | Wx::LC_EDIT_LABELS)
+    @list.set_size([400, 200])
+  end
+
+  def cleanup
+    @list.destroy
+    super
+  end
+
+  attr_reader :list
+
+  def test_sort
+    list.insert_column(0, "Column 0")
+
+    list.insert_item(0, "Item 0")
+    list.set_item_data(0, 0)
+    list.insert_item(1, "Item 1")
+    list.set_item_data(1, 1)
+
+    list.sort_items { |i1, i2, _| i2 <=> i1 } # inverted compare
+
+    assert_equal("Item 1", list.get_item_text(0))
+    assert_equal("Item 0", list.get_item_text(1))
+  end
+
+  if Wx.has_feature?(:HAS_LISTCTRL_COLUMN_ORDER)
+
+  def test_columns_order
+    3.times { |i| list.insert_column(i, "Column #{i}") }
+
+    order = [2, 0, 1]
+    list.set_columns_order(order)
+
+    # now list.get_columns_order() will return order
+    assert_equal(order, list.get_columns_order)
+    # and list.get_column_index_from_order(n) will return order[n]
+    assert_equal(order[1], list.get_column_index_from_order(1))
+    # and list.get_column_order() will return 1, 2 and 0 for the column 0,
+    # 1 and 2 respectively
+    assert_equal(1, list.get_column_order(0))
+  end
+
+  end
+
+end

data/tests/test_log.rb

@@ -0,0 +1,163 @@
+
+require_relative './lib/wxapp_runner'
+
+class LogTests < Test::Unit::TestCase
+
+  class TestLogBase < Wx::Log
+
+    def initialize
+      super
+      @logs = ::Array.new(Wx::LOG_Trace + 1)
+      @logsInfo = ::Array.new(Wx::LOG_Trace + 1)
+    end
+
+    def get_log(level)
+      @logs[level].to_s
+    end
+
+    def get_info(level)
+      @logsInfo[level]
+    end
+
+    def clear
+      @logs = ::Array.new(Wx::LOG_Trace + 1)
+      @logsInfo = ::Array.new(Wx::LOG_Trace + 1)
+    end
+
+  end
+
+  class TestLog < TestLogBase
+
+    protected
+
+    def do_log_record(level, msg, info)
+      @logs[level] = msg
+      # do not keep log info objects because these (and their state) are purely transient data
+      # that can only be reliably accessed (or passed on) within this call scope
+      @logsInfo[level] = { filename: info.filename, line: info.line, func: info.func, component: info.component }
+    end
+
+  end
+
+  def setup
+    super
+    @logOld = Wx::Log.set_active_target(@log = TestLog.new)
+    @logWasEnabled = Wx::Log.enable_logging
+  end
+
+  def cleanup
+    Wx::Log.set_active_target(@logOld)
+    Wx::Log.enable_logging(@logWasEnabled)
+    super
+  end
+
+  def test_functions
+    Wx.log_message("Message")
+    assert_equal("Message", @log.get_log(Wx::LOG_Message))
+
+    Wx.log_error("Error %d", 17)
+    assert_equal("Error 17", @log.get_log(Wx::LOG_Error))
+
+    Wx.log_debug("Debug")
+    if Wx::WXWIDGETS_DEBUG_LEVEL > 0
+      assert_equal( "Debug", @log.get_log(Wx::LOG_Debug))
+    else
+      assert_equal( "", @log.get_log(Wx::LOG_Debug))
+    end
+  end
+
+  def test_null
+    Wx::LogNull.no_log do
+      Wx.log_warning("%s warning", "Not important")
+
+      assert_equal("", @log.get_log(Wx::LOG_Warning))
+      end
+
+    Wx.log_warning("%s warning", "Important")
+    assert_equal("Important warning", @log.get_log(Wx::LOG_Warning))
+  end
+
+  def test_component
+    Wx.log_message('Message')
+    assert_equal('wxapp',
+                 @log.get_info(Wx::LOG_Message)[:component])
+
+    # completely disable logging for this component
+    Wx::Log.set_component_level('test/ignore', Wx::LOG_FatalError)
+
+    # but enable it for one of its subcomponents
+    Wx::Log.set_component_level('test/ignore/not', Wx::LOG_Max)
+
+    Wx::Log.for_component('test/ignore') do
+      # this shouldn't be output as this component is ignored
+      Wx::log_error('Error')
+      assert_equal('', @log.get_log(Wx::LOG_Error))
+
+      # and so are its subcomponents
+      Wx.log_error('Error', component: 'test/ignore/sub/subsub') # explicit component: overrules scoped setting
+      assert_equal('', @log.get_log(Wx::LOG_Error))
+
+      Wx.log_error('Error', component: 'test/ignore/not')
+      assert_equal('Error', @log.get_log(Wx::LOG_Error))
+
+      # restore the original component value
+    end
+  end
+
+  def test_repetition_counting
+    Wx::Log.set_repetition_counting(true)
+
+    Wx.log_message('Message')
+    assert_equal('Message', @log.get_log(Wx::LOG_Message))
+
+    @log.clear
+    Wx.log_message('Message')
+    assert_equal('', @log.get_log(Wx::LOG_Message))
+    Wx.log_message('Message')
+    assert_equal('', @log.get_log(Wx::LOG_Message))
+
+    Wx.log_info('Another message')
+    if Wx.has_feature?(:USE_INTL)
+      # don't what language may come out so just test if not empty anymore
+      assert_not_empty(@log.get_log(Wx::LOG_Message))
+    else
+      assert_match(/The previous message.*repeated/, @log.get_log(Wx::LOG_Message))
+    end
+    assert_equal('Another message', @log.get_log(Wx::LOG_Info))
+
+    Wx::Log.set_repetition_counting(false)
+  end
+
+  class MyBufferInterposer < Wx::LogInterposer
+
+    def initialize
+      super
+      @buffer = []
+    end
+
+    attr_reader :buffer
+
+    def do_log_text(msg)
+      @buffer << msg
+    end
+    protected :do_log_text
+
+  end
+
+  def test_log_interposer
+    buffer_log = MyBufferInterposer.new
+    assert_empty(buffer_log.buffer)
+
+    Wx.log_message('Message')
+    assert_equal("Message", @log.get_log(Wx::LOG_Message))
+    assert_equal(1, buffer_log.buffer.size)
+    assert_match(/Message/, buffer_log.buffer.first)
+
+    Wx.log_warning('Message')
+    assert_equal("Message", @log.get_log(Wx::LOG_Warning))
+    assert_equal(2, buffer_log.buffer.size)
+    assert_match(/Message/, buffer_log.buffer.last)
+
+  end
+
+end