wxruby3 0.9.0.pre.rc.2 → 0.9.0.pre.rc.3

data/tests/test_box_sizer.rb

@@ -0,0 +1,161 @@
+
+require_relative './lib/wxframe_runner'
+
+class BoxSizerTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @win = Wx::Window.new(test_frame, Wx::ID_ANY)
+    @sizer = Wx::HBoxSizer.new
+    @win.set_client_size(127, 35)
+    @win.sizer = @sizer
+  end
+
+  def cleanup
+    test_frame.destroy_children
+    @win = nil
+    @sizer = nil
+    super
+  end
+
+  attr_reader :win, :sizer
+
+  def test_size
+    sizeTotal = win.get_client_size
+    sizeChild = sizeTotal / 2
+
+    child = Wx::Window.new(win, Wx::ID_ANY, Wx::DEFAULT_POSITION, sizeChild)
+    sizer.add(child)
+    win.layout
+    assert(child.size == sizeChild)
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new(1))
+    win.layout
+    assert(child.size == [sizeTotal.x, sizeChild.y])
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new(1).expand)
+    win.layout
+    assert(child.size == sizeTotal)
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new)
+    sizer.set_item_min_size(child, sizeTotal*2)
+    win.layout
+    assert(child.size == sizeTotal)
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new.expand)
+    sizer.set_item_min_size(child, sizeTotal*2)
+    win.layout
+    assert(child.size == sizeTotal)
+  end
+
+  class << self
+
+    def _ltd(*args)
+      @ltd_klass ||= Struct.new(:prop, :minsize, :x, :sizes, :dont_permute) do
+        def add_to_sizer(sizer, win, n)
+          sizer.add(win, Wx::SizerFlags.new(prop[n]))
+          sizer.set_item_min_size(win, Wx::Size.new(minsize[n], -1))
+        end
+      end
+      @ltd_klass.new(*args)
+    end
+
+  end
+
+  LayoutTestData = [
+    # some really simple cases (no need to permute those, they're
+    # symmetrical anyhow)
+    _ltd( [ 1, 1, 1, ], [  50,  50,  50, ], 150, [  50,  50,  50, ], true ),
+    _ltd( [ 2, 2, 2, ], [  50,  50,  50, ], 600, [ 200, 200, 200, ], true ),
+
+    # items with different proportions and min sizes when there is enough
+    # space to lay them out
+    _ltd( [ 1, 2, 3, ], [   0,   0,   0, ], 600, [ 100, 200, 300, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 600, [ 100, 200, 300, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100,  50,  50, ], 600, [ 100, 200, 300, ] ),
+    _ltd( [ 0, 1, 1, ], [ 200, 100, 100, ], 600, [ 200, 200, 200, ] ),
+    _ltd( [ 0, 1, 2, ], [ 300, 100, 100, ], 600, [ 300, 100, 200, ] ),
+    _ltd( [ 0, 1, 1, ], [ 100,  50,  50, ], 300, [ 100, 100, 100, ] ),
+    _ltd( [ 0, 1, 2, ], [ 100,  50,  50, ], 400, [ 100, 100, 200, ] ),
+
+    # cases when there is not enough space to lay out the items correctly
+    # while still respecting their min sizes
+    _ltd( [ 0, 1, 1, ], [ 100, 150,  50, ], 300, [ 100, 150,  50, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 300, [ 100, 100, 100, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100,  50,  50, ], 300, [ 100,  80, 120, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100,  10,  10, ], 150, [ 100,  20,  30, ] ),
+
+    # cases when there is not enough space even for the min sizes (don't
+    # permute in these cases as the layout does depend on the item order
+    # because the first ones have priority)
+    _ltd( [ 1, 2, 3, ], [ 100,  50,  50, ], 150, [ 100,  50,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 200, [ 100, 100,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 150, [ 100,  50,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ],  50, [  50,   0,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ],   0, [   0,   0,   0, ], true ),
+  ]
+
+  def test_size_3
+    child = [Wx::Window.new(win, Wx::ID_ANY),
+             Wx::Window.new(win, Wx::ID_ANY),
+             Wx::Window.new(win, Wx::ID_ANY)]
+
+    LayoutTestData.each_with_index do |ltd, i|
+      # the results shouldn't depend on the order of items except in the
+      # case when there is not enough space for even the fixed width items
+      # (in which case the first ones might get enough of it but not the
+      # last ones) so test a couple of permutations of test data unless
+      # specifically disabled for this test case
+      3.times do |p|
+        case p
+        when 0
+          # nothing, use original data
+        when 1
+          # exchange first and last elements
+          ltd.prop[0], ltd.prop[2] = ltd.prop[2], ltd.prop[0]
+          ltd.minsize[0], ltd.minsize[2] = ltd.minsize[2], ltd.minsize[0]
+          ltd.sizes[0], ltd.sizes[2] = ltd.sizes[2], ltd.sizes[0]
+        when 2
+          # exchange the original third and second elements
+          ltd.prop[0], ltd.prop[1] = ltd.prop[1], ltd.prop[0]
+          ltd.minsize[0], ltd.minsize[1] = ltd.minsize[1], ltd.minsize[0]
+          ltd.sizes[0], ltd.sizes[1] = ltd.sizes[1], ltd.sizes[0]
+        end
+
+        sizer.clear
+
+        child.each_with_index { |c, j| ltd.add_to_sizer(sizer, c, j) }
+
+        win.set_client_size(ltd.x, -1)
+        win.layout
+
+        child.each_with_index do |c, j|
+          assert_equal(ltd.sizes[j], c.size.x,
+                       "test #{i}, permutation #{p}: wrong size for child #{j} for total size #{ltd.x}")
+        end
+
+        # don't try other permutations if explicitly disabled
+        break if ltd.dont_permute
+      end
+    end
+  end
+
+  def test_min_size
+    child = Wx::Window.new(win, Wx::ID_ANY)
+    child.set_initial_size([10, -1])
+    sizer.add(child)
+
+    # Setting minimal size explicitly must make get_min_size() return at least
+    # this size even if it needs a much smaller one.
+    sizer.set_min_size(100, 0)
+    assert(sizer.get_min_size.x == 100)
+
+    sizer.layout
+    assert(sizer.min_size.x == 100)
+  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_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

data/tests/test_std_controls.rb

@@ -371,3 +371,61 @@ class ChoiceTests < WxRuby::Test::GUITests
   end
 
 end
+
+class GaugeTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @gauge = Wx::Gauge.new(test_frame, range: 100)
+  end
+
+  def cleanup
+    test_frame.destroy_children
+    super
+  end
+
+  attr_reader :gauge
+
+  def test_direction
+    #We should default to a horizontal gauge
+    assert(!gauge.is_vertical)
+
+    gauge.destroy
+    @gauge = Wx::Gauge.new(test_frame, range: 100, style: Wx::GA_VERTICAL)
+
+    assert(gauge.vertical?)
+
+    gauge.destroy
+    @gauge = Wx::Gauge.new(test_frame, range: 100, style: Wx::GA_HORIZONTAL)
+
+    assert(!gauge.vertical?)
+  end
+
+  def test_range
+    assert_equal(100, gauge.get_range)
+
+    gauge.set_range(50)
+
+    assert_equal(50, gauge.get_range)
+
+    gauge.set_range(0)
+
+    assert_equal(0, gauge.range)
+  end
+
+  def test_value
+    assert_equal(0, gauge.get_value)
+
+    gauge.set_value(50)
+
+    assert_equal(50, gauge.value)
+
+    gauge.value = 0
+
+    assert_equal(0, gauge.get_value)
+
+    gauge.set_value(100)
+
+    assert_equal(100, gauge.value)
+  end
+end

data/tests/test_timer.rb

@@ -0,0 +1,95 @@
+
+require_relative './lib/wxapp_runner'
+
+class TimerTests < Test::Unit::TestCase
+
+  class TimerCounterHandler < Wx::EvtHandler
+
+    def initialize
+      super
+      @count = 0
+      evt_timer Wx::ID_ANY, :on_timer
+    end
+
+    attr_reader :count
+
+    private
+
+    def on_timer(_evt)
+      @count += 1
+      tick
+    end
+
+    def tick
+      # noop
+    end
+
+  end
+
+  def test_one_shot
+
+    handler = Class.new(TimerCounterHandler) do
+      def initialize(loop)
+        super()
+        @loop = loop
+      end
+
+      def run
+        @timer = Wx::Timer.new(self)
+        @timer.start(200, true)
+        @loop.run
+      end
+
+      def tick
+        @timer.stop
+        @loop.exit
+      end
+    end.new(Wx::EventLoop.new)
+
+    handler.run
+
+    assert_equal(1, handler.count)
+  end
+
+  def test_multiple
+
+
+    handler = Class.new(TimerCounterHandler) do
+      def initialize(loop)
+        super()
+        @loop = loop
+      end
+
+      def run
+        @timer = Wx::Timer.new(self)
+        @timer.start(100)
+        # run for 2 seconds
+        @tm_end = Time.now + 2
+        @loop.run
+      end
+
+      def tick
+        # exit after 2 seconds
+        unless Time.now < @tm_end
+          @timer.stop
+          @loop.exit
+        end
+      end
+    end.new(Wx::EventLoop.new)
+
+
+    handler.run
+
+    # we can't count on getting exactly 20 ticks but we shouldn't get more
+    # than this
+    num_ticks = handler.count
+    assert( num_ticks <= 20 )
+
+    # and we should get a decent number of them but if the system is very
+    # loaded (as happens with build bot slaves running a couple of builds in
+    # parallel actually) it may be much less than 20 so just check that we get
+    # more than one
+    assert( num_ticks > 1 )
+  end
+  
+end