wxruby3 0.9.0.pre.rc.1 → 0.9.0.pre.rc.3

data/samples/propgrid/propgrid.rb

@@ -603,6 +603,9 @@ class FormMain < Wx::Frame
     menuHelp = Wx::Menu.new
 
     menuHelp.append(ID::ABOUT, '&About', 'Show about dialog')
+    if Wx::PLATFORM == 'WXOSX'
+      Wx.get_app.mac_about_menu_itemid = ID::ABOUT
+    end
 
     menuTools1.append(ID::APPENDPROP, 'Append New Property')
     menuTools1.append(ID::APPENDCAT, "Append New Category\tCtrl-S")

data/samples/sampler/editor.rb

@@ -34,8 +34,8 @@ module WxRuby
   end
 
   class SampleEditPanel
-    def initialize(parent, sample)
-      @frame = parent
+    def initialize(frame, parent, sample)
+      @frame = frame
       @sample = sample
       @splitter = Wx::SplitterWindow.new(parent, Wx::ID_ANY)
 
@@ -67,6 +67,8 @@ module WxRuby
       @edt_book.set_selection(0)
     end
 
+    attr_reader :splitter
+
     def add_editor_page(filename, pgnr)
       panel = Wx::Panel.new(@edt_book, Wx::ID_ANY)
       edt_sizer = Wx::HBoxSizer.new
@@ -306,30 +308,36 @@ module WxRuby
       menuBar.append(menuHelp, "&Help")
       set_menu_bar(menuBar)
 
-      tb = create_tool_bar(Wx::TB_HORIZONTAL | Wx::NO_BORDER | Wx::TB_FLAT)
-      tb.tool_bitmap_size = [ 16, 16 ]
-      tb.add_tool(ID::SAVE, 'Save', bitmap(:filesave), 'Save the sample to a local folder')
-      tb.add_tool(ID::RUN, 'Run', bitmap(:play), 'Run the (changed) sample')
-      tb.add_separator
-      tb.add_tool(ID::UNDO, 'Undo', bitmap(:undo), 'Undo change')
-      tb.add_tool(ID::REDO, 'Redo', bitmap(:redo), 'Redo change')
-      tb.add_separator
-      tb.add_tool(ID::COPY, 'Copy', bitmap(:copy), 'Copy selection')
-      tb.add_tool(ID::CUT, 'Cut', bitmap(:cut), 'Cut selection')
-      tb.add_tool(ID::PASTE, 'Paste', bitmap(:paste), 'Paste selection')
-      tb.add_separator
-      tb.add_tool(ID::FIND, 'Find', bitmap(:find), 'Show Find Dialog')
-      tb.add_tool(ID::FIND_NEXT, 'FindNext', bitmap(:forward), 'Find next occurrence of the search phrase')
-      tb.add_tool(ID::FIND_PREV, 'FindPrev', bitmap(:back), 'Find previous occurrence of the search phrase')
-      tb.add_tool(ID::REPLACE, 'Replace', bitmap(:findrepl), 'Show Replace Dialog')
-      tb.realize
+      panel = Wx::Panel.new(self)
+      panel_szr = Wx::VBoxSizer.new
+      @tbar = Wx::ToolBar.new(panel, style: Wx::TB_HORIZONTAL | Wx::NO_BORDER | Wx::TB_FLAT)
+      @tbar.tool_bitmap_size = [ 16, 16 ]
+      @tbar.add_tool(ID::SAVE, 'Save', bitmap(:filesave), 'Save the sample to a local folder')
+      @tbar.add_tool(ID::RUN, 'Run', bitmap(:play), 'Run the (changed) sample')
+      @tbar.add_separator
+      @tbar.add_tool(ID::UNDO, 'Undo', bitmap(:undo), 'Undo change')
+      @tbar.add_tool(ID::REDO, 'Redo', bitmap(:redo), 'Redo change')
+      @tbar.add_separator
+      @tbar.add_tool(ID::COPY, 'Copy', bitmap(:copy), 'Copy selection')
+      @tbar.add_tool(ID::CUT, 'Cut', bitmap(:cut), 'Cut selection')
+      @tbar.add_tool(ID::PASTE, 'Paste', bitmap(:paste), 'Paste selection')
+      @tbar.add_separator
+      @tbar.add_tool(ID::FIND, 'Find', bitmap(:find), 'Show Find Dialog')
+      @tbar.add_tool(ID::FIND_NEXT, 'FindNext', bitmap(:forward), 'Find next occurrence of the search phrase')
+      @tbar.add_tool(ID::FIND_PREV, 'FindPrev', bitmap(:back), 'Find previous occurrence of the search phrase')
+      @tbar.add_tool(ID::REPLACE, 'Replace', bitmap(:findrepl), 'Show Replace Dialog')
+      @tbar.realize
+      panel_szr.add(@tbar)
+
+      # Create the editor panel
+      @editors = SampleEditPanel.new(self, panel, @sample)
+      panel_szr.add(@editors.splitter, 1, Wx::GROW, 0)
+
+      panel.set_sizer(panel_szr)
 
       create_status_bar(1)
       set_status_text("Welcome to wxRuby Sample editor.")
 
-      # Create the editor panel
-      @editors = SampleEditPanel.new(self, @sample)
-
       evt_idle(:on_idle)
 
       evt_update_editor_ui(:on_update_editor_ui)
@@ -382,15 +390,15 @@ module WxRuby
     def update_undo_redo(f_undo, f_redo)
       @m_undo.enable(f_undo)
       @m_redo.enable(f_redo)
-      self.tool_bar.enable_tool(ID::UNDO, f_undo)
-      self.tool_bar.enable_tool(ID::REDO, f_redo)
+      @tbar.enable_tool(ID::UNDO, f_undo)
+      @tbar.enable_tool(ID::REDO, f_redo)
       set_status_text('')
     end
     private :update_undo_redo
 
     def update_paste(f_paste)
       @m_paste.enable(f_paste)
-      self.tool_bar.enable_tool(ID::PASTE, f_paste)
+      @tbar.enable_tool(ID::PASTE, f_paste)
       set_status_text('')
     end
 

data/samples/sampler/sample.rb

@@ -293,7 +293,7 @@ module WxRuby
               category.modulize!
               Dir[File.join(entry, '*.rb')].each do |rb|
                 # only if this is a file (paranoia check) and contains 'include WxRuby::Sample'
-                if File.file?(rb) && (sample_lns = File.readlines(rb)).any? { |ln| /\s+include\s+WxRuby::Sample/ =~ ln }
+                if File.file?(rb) && (sample_lns = File.readlines(rb, encoding: 'utf-8')).any? { |ln| /\s+include\s+WxRuby::Sample/ =~ ln }
                   # register currently required files
                   cur_loaded = ::Set.new($LOADED_FEATURES)
                   @loading_sample = rb
@@ -302,7 +302,7 @@ module WxRuby
                   # in the class/module scope in which the dialog class is defined working from the dialog class name;
                   # this will fail for anonymous modules as these cannot be identified by name)
                   sample_mod = Sample.const_set("SampleLoader_#{File.basename(rb, '.*').modulize!}", Module.new)
-                  sample_mod.module_eval File.read(rb), rb, 1
+                  sample_mod.module_eval File.read(rb, encoding: 'utf-8'), rb, 1
                   # determine additionally required files
                   new_loaded = ::Set.new($LOADED_FEATURES) - cur_loaded
                   sample_captures.each do |mod|

data/samples/sampler/stc_editor.rb

@@ -114,8 +114,9 @@ module WxRuby
 
     def default_theme
       c_maroon = Wx::Colour.new('Maroon')
-      style_set_foreground(Wx::STC::STC_STYLE_DEFAULT, Wx::BLACK);
-      style_set_background(Wx::STC::STC_STYLE_DEFAULT, Wx::WHITE);
+      style_set_foreground(Wx::STC::STC_STYLE_DEFAULT, Wx::BLACK)
+      style_set_background(Wx::STC::STC_STYLE_DEFAULT, Wx::WHITE)
+      set_caret_foreground(Wx::BLACK)
       style_clear_all
       style_set_foreground(Wx::STC::STC_STYLE_LINENUMBER, Wx::Colour.new('Dark Grey'))
       style_set_background(Wx::STC::STC_STYLE_LINENUMBER, Wx::WHITE);
@@ -160,6 +161,7 @@ module WxRuby
       c_str = Wx::Colour.new('Lime Green')
       style_set_background(Wx::STC::STC_STYLE_DEFAULT, bg)
       style_set_foreground(Wx::STC::STC_STYLE_DEFAULT, Wx::WHITE)
+      set_caret_foreground(Wx::WHITE)
       style_clear_all
       style_set_background(Wx::STC::STC_STYLE_LINENUMBER, bg)
       style_set_foreground(Wx::STC::STC_STYLE_LINENUMBER, Wx::WHITE)

data/tests/lib/item_container_tests.rb

@@ -0,0 +1,82 @@
+
+module ItemContainerTests
+
+  def test_ic_append
+    container.append("item 0")
+
+    assert_equal("item 0", container.get_string(0))
+
+    container.append(['item 1', 'item 2'])
+
+    assert_equal("item 1", container.get_string(1))
+    assert_equal("item 2", container.get_string(2))
+
+    container.append(['item 3', 'item 4'])
+
+    assert_equal("item 3", container.get_string(3))
+    assert_equal("item 4", container.get_string(4))
+  end
+
+  def test_ic_insert
+    assert_equal(0, container.insert("item 0", 0))
+    assert_equal("item 0", container.get_string(0))
+
+    assert_equal(1, container.insert(['item 1', 'item 2'], 0))
+
+    assert_equal("item 1", container.get_string(0))
+    assert_equal("item 2", container.get_string(1))
+
+    assert_equal(2, container.insert(['item 3', 'item 4'], 1))
+    assert_equal("item 3", container.get_string(1))
+    assert_equal("item 4", container.get_string(2))
+  end
+  
+  def test_ic_count
+    assert(container.empty?)
+    assert_with_assertion_failure { container.get_string(0) }
+
+    container.append(['item 0', 'item 1', 'item 2', 'item 3'])
+
+    assert(!container.empty?)
+    assert_equal(4, container.count)
+
+    container.delete(0)
+
+    assert_equal(3, container.count)
+
+    container.delete(0)
+    container.delete(0)
+
+    assert_equal(1, container.count)
+
+    container.insert(['item 0', 'item 1', 'item 2', 'item 3'], 1)
+
+    assert_equal(5, container.count)
+    assert_with_assertion_failure { container.get_string(10) }
+  end
+
+  def test_ic_item_selection
+    container.append(['item 0', 'item 1', 'item 2', 'ITEM 2'])
+
+    container.set_selection(Wx::NOT_FOUND)
+    assert_equal(Wx::NOT_FOUND, container.get_selection)
+    assert_equal("", container.get_string_selection)
+
+    container.set_selection(1)
+    assert_equal(1, container.get_selection)
+    assert_equal("item 1", container.get_string_selection)
+
+    assert(container.set_string_selection("item 2"))
+    assert_equal(2, container.get_selection)
+    assert_equal("item 2", container.get_string_selection)
+
+    # Check that selecting a non-existent item fails.
+    assert(!container.set_string_selection("bloordyblop"))
+
+    # Check that SetStringSelection() is case-insensitive.
+    assert(container.set_string_selection("ITEM 2"))
+    assert_equal(2, container.get_selection)
+    assert_equal("item 2", container.get_string_selection)
+  end
+    
+end

data/tests/lib/text_entry_tests.rb

@@ -0,0 +1,80 @@
+
+module TextEntryTests
+
+  def test_te_set_value
+    text_entry.set_focus # removes the 'Hint' test which in GTK2 causes problems
+    assert(text_entry.empty?)
+
+    text_entry.value = 'foo'
+    assert_equal('foo', text_entry.value)
+
+    text_entry.value = ''
+    assert(text_entry.empty?)
+
+    text_entry.value = 'hi'
+    assert_equal('hi', text_entry.value)
+
+    text_entry.value = 'bye'
+    assert_equal('bye', text_entry.value)
+  end
+
+  def test_te_text_change_events
+    updates = count_events(text_entry, :evt_text) do |c_upd|
+
+      # WXQT only sends event when text changes
+      unless Wx::PLATFORM == 'WXQT'
+        text_entry.value = ''
+        assert_equal(1, c_upd.count)
+        c_upd.count = 0
+      end
+
+      text_entry.value = 'foo'
+      assert_equal(1, c_upd.count)
+      c_upd.count = 0
+
+      # WXQT only sends event when text changes
+      unless Wx::PLATFORM == 'WXQT'
+        text_entry.value = 'foo'
+        assert_equal(1, c_upd.count)
+        c_upd.count = 0
+      end
+
+      text_entry.value = ''
+      assert_equal(1, c_upd.count)
+      c_upd.count = 0
+
+      text_entry.change_value('bar')
+      assert_equal(0, c_upd.count)
+
+      text_entry.append_text('bar')
+      assert_equal(1, c_upd.count)
+      c_upd.count = 0
+
+      text_entry.replace(3, 6, 'baz')
+      assert_equal(1, c_upd.count)
+      c_upd.count = 0
+
+      text_entry.remove(0, 3)
+      assert_equal(1, c_upd.count)
+      c_upd.count = 0
+
+      text_entry.write_text('foo')
+      assert_equal(1, c_upd.count)
+      c_upd.count = 0
+
+      text_entry.clear
+      assert_equal(1, c_upd.count)
+      c_upd.count = 0
+
+      text_entry.change_value('')
+      assert_equal(0, c_upd.count)
+
+      text_entry.change_value('non-empty')
+      assert_equal(0, c_upd.count)
+
+      text_entry.change_value('')
+      assert_equal(0, c_upd.count)
+    end
+  end
+
+end

data/tests/lib/wxapp_runner.rb

@@ -60,5 +60,17 @@ module Test
         end
       end
     end
+
+    class TestCase
+
+      def self.is_ci_build?
+        !!ENV['GITHUB_ACTION']
+      end
+
+      def is_ci_build?
+        TestCase.is_ci_build?
+      end
+
+    end
   end
 end

data/tests/lib/wxframe_runner.rb

@@ -6,7 +6,27 @@ module WxRuby
   module Test
 
     class App < Wx::App
+
+      Assert = Struct.new(:file, :line, :func, :condition, :message)
+
+      class AssertFailureSink
+        def initialize
+          @asserts = []
+        end
+
+        attr_reader :asserts
+
+        def asserts?
+          !@asserts.empty?
+        end
+
+        def <<(assert)
+          @asserts << assert
+        end
+      end
+
       def on_init
+        @assert_sink = nil
         @tests_have_run = false
         evt_idle :on_idle
         @frame = Wx::Frame.new(nil, size: [600,400])
@@ -21,6 +41,30 @@ module WxRuby
       end
 
       attr_reader :frame
+
+      def open_assert_sink
+        @assert_sink = AssertFailureSink.new
+      end
+
+      def close_assert_sink
+        @assert_sink = nil
+      end
+
+      def asserts
+        @assert_sink.asserts
+      end
+
+      def asserts?
+        @assert_sink.asserts?
+      end
+
+      def on_assert_failure(file, line, func, condition, message)
+        if @assert_sink
+          @assert_sink << Assert.new(file, line, func, condition, message)
+        else
+          super
+        end
+      end
     end
 
     class GUITests < ::Test::Unit::TestCase
@@ -38,20 +82,61 @@ module WxRuby
         def inc
           @count +=1
         end
+
+        def wait_event(msec)
+          start = Time.now
+          msec /= 1000.0
+          while (Time.now - start) < msec
+            Wx.get_app.yield
+            if @count > 0
+              raise StandardError.new("Too many events. Expected a single one.") unless @count == 1
+              @count = 0
+              return true
+            end
+            sleep(50.0/1000.0)
+          end
+          false
+        end
+      end
+
+      def self.has_ui_simulator?
+        Wx.has_feature?(:USE_UIACTIONSIMULATOR) && (Wx::PLATFORM != 'WXOSX' || Wx::WXWIDGETS_VERSION >= '3.3')
+      end
+
+      def has_ui_simulator?
+        GUITests.has_ui_simulator?
       end
 
       def count_events(win, evt, id1=Wx::ID_ANY, id2=nil)
         return 0 unless block_given?
         evt_count = EventCounter.new
-        if id2.nil?
-          win.event_handler.send(evt.to_sym, id1, ->(_evt){ evt_count.inc })
+        if Wx::EvtHandler.event_type_arity(evt) == 0
+          win.event_handler.send(evt.to_sym, ->(evt){ evt_count.inc; evt.skip if !evt.command_event? })
+        elsif id2.nil?
+          win.event_handler.send(evt.to_sym, id1, ->(evt){ evt_count.inc; evt.skip if !evt.command_event? })
         else
-          win.event_handler.send(evt.to_sym, id1, id2, ->(_evt){ evt_count.inc })
+          win.event_handler.send(evt.to_sym, id1, id2, ->(evt){ evt_count.inc; evt.skip if !evt.command_event? })
+        end
+        begin
+          yield evt_count
+        ensure
+          win.event_handler.disconnect(id1, id2 || Wx::ID_ANY, evt.to_sym)
         end
-        yield evt_count
         evt_count.count
       end
 
+      def assert_with_assertion_failure(max_asserts: nil, func: nil, &block)
+        Wx.get_app.open_assert_sink
+        begin
+          block.call
+          raise StandardError.new('No Wx assertion failure captured!') unless Wx.get_app.asserts?
+          raise StandardError.new("Too many assertion failures captures! Expected max #{max_asserts}, captured #{Wx.get_app.asserts.size}") if max_asserts && max_asserts < Wx.get_app.asserts.size
+          raise StandardError.new("Unexpected assertions failures. Expected assertion failure from #{func} but captured assertions from #{Wx.get_app.asserts.collect {|a| a.func } }") if func && !Wx.get_app.asserts.any? { |a| a.func == func }
+        ensure
+          Wx.get_app.close_assert_sink
+        end
+      end
+
     end
 
   end

data/tests/test_art.rb

@@ -76,6 +76,15 @@ class TestArt < Test::Unit::TestCase
     end
   end
 
+  def test_image_histogram
+    img = Wx.Image(:wxruby, Wx::BitmapType::BITMAP_TYPE_JPEG)
+    img_hist = img.compute_histogram
+    assert(img_hist.is_a?(::Hash))
+    assert(img_hist.is_a?(Wx::Image::Histogram))
+    assert(img_hist.size > 0)
+    assert(img_hist.values.all? { |index, value| index>=0 && value>=1 })
+  end
+
   def test_art
     art = nil
     assert_nothing_raised do

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_ext_controls.rb

@@ -0,0 +1,28 @@
+
+require_relative './lib/wxframe_runner'
+require_relative './lib/text_entry_tests'
+
+class SearchCtrlTests < WxRuby::Test::GUITests
+
+  include TextEntryTests
+
+  def setup
+    super
+    @search = Wx::SearchCtrl.new(test_frame, name: 'SearchCtrl')
+    Wx.get_app.yield
+  end
+
+  def cleanup
+    @search.destroy
+    Wx.get_app.yield
+    super
+  end
+
+  attr_reader :search
+  alias :text_entry :search
+
+  def test_search
+    assert_equal('', search.get_value)
+  end
+
+end