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

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,341 @@ 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)
+  if has_ui_simulator?
+  def test_max_length
+    sim = Wx::UIActionSimulator.new
 
-    def test_text
-      assert_equal('', text.get_value)
-      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
 
-      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
 
-          sim.text('Hello')
-          Wx.get_app.yield
+        assert_equal('Hello', text_entry.get_value)
+        assert_equal(5, c_upd.count)
 
-          assert_equal('Hello', text.get_value)
-          assert_equal(5, c_upd.count)
+        text_entry.set_max_length(10)
+        sim.text('World')
+        Wx.get_app.yield
 
-          text.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)
 
-          assert_equal('HelloWorld', text.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
+
+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