teek-ui 0.1.0

data/test/test_scrollable.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# ui.scrollable wraps arbitrary content in a scrolled frame - a canvas +
+# embedded viewport, since arbitrary widgets have no Tk scrolling protocol
+# of their own to hook a scrollbar into. A bare list/text_area/table/
+# tree/canvas auto-attaches a scrollbar wherever it's declared instead,
+# with no ui.scrollable wrapper needed - see test_native_scrollable.rb.
+# See Realizer#create_scrollable.
+class TestScrollable < Minitest::Test
+  include TeekTestHelper
+
+  def test_wraps_content_in_a_canvas_and_embedded_viewport
+    assert_tk_app("a scrollable panel of arbitrary widgets should be wrapped in a canvas + embedded frame") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.scrollable(:region) do |s|
+          s.column(:rows) { |c| 30.times { |i| c.button(text: "Row #{i}") } }
+        end
+      end
+      session.run_async
+      session.app.update
+      session.app.update_idletasks
+
+      region_path = session[:region].path
+      canvas_path = "#{region_path}.canvas"
+      viewport_path = "#{canvas_path}.viewport"
+      rows_path = session[:rows].path
+
+      assert_equal '1', session.app.tcl_eval("winfo exists #{canvas_path}")
+      assert_equal '1', session.app.tcl_eval("winfo exists #{viewport_path}")
+      assert_equal viewport_path, rows_path.sub(/\.\w+\z/, ''), "the column should live inside the viewport, not directly under the scrollable"
+      assert_equal '1', session.app.tcl_eval("winfo exists #{region_path}.vsb")
+
+      scrollregion = session.app.tcl_eval("#{canvas_path} cget -scrollregion")
+      refute_empty scrollregion, "the scrollregion should track the viewport's content size"
+      height = scrollregion.split.last.to_i
+      assert_operator height, :>, 200, "30 stacked buttons should produce a tall scrollregion"
+
+      session.app.destroy
+    end
+  end
+
+  def test_y_defaults_to_true_and_x_to_false
+    assert_tk_app("a scrollable should default to a vertical scrollbar only") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.scrollable(:region) { |s| s.column { |c| c.button(text: 'Row') } }
+      end
+      session.run_async
+      session.app.update
+
+      region_path = session[:region].path
+      assert_equal '1', session.app.tcl_eval("winfo exists #{region_path}.vsb")
+      assert_equal '0', session.app.tcl_eval("winfo exists #{region_path}.hsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_y_false_omits_the_vertical_scrollbar
+    assert_tk_app("y: false should leave no scrollbar at all if x: isn't given either") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.scrollable(:region, y: false) { |s| s.column { |c| c.button(text: 'Row') } }
+      end
+      session.run_async
+      session.app.update
+
+      region_path = session[:region].path
+      assert_equal '0', session.app.tcl_eval("winfo exists #{region_path}.vsb")
+      assert_equal '0', session.app.tcl_eval("winfo exists #{region_path}.hsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_x_true_also_wires_a_horizontal_scrollbar
+    assert_tk_app("x: true should additionally wire a horizontal scrollbar") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.scrollable(:region, x: true) { |s| s.column { |c| c.button(text: 'Row') } }
+      end
+      session.run_async
+      session.app.update
+
+      region_path = session[:region].path
+      assert_equal '1', session.app.tcl_eval("winfo exists #{region_path}.hsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_syncs_the_viewport_width_to_the_canvas_by_default
+    assert_tk_app("without x: scrolling, resizing the canvas should resize the embedded viewport to match") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.window(:win, geometry: '400x300') do |w|
+          w.scrollable(:region) { |s| s.column(:rows) { |c| c.button(text: 'Row') } }
+        end
+      end
+      session.run_async
+      session[:win].show
+      session.app.update
+      session.app.update_idletasks
+
+      canvas_path = "#{session[:region].path}.canvas"
+      viewport_path = "#{canvas_path}.viewport"
+
+      canvas_width = session.app.tcl_eval("winfo width #{canvas_path}")
+      viewport_width = session.app.tcl_eval("winfo width #{viewport_path}")
+      assert_equal canvas_width, viewport_width
+
+      session.app.destroy
+    end
+  end
+
+  def test_with_x_true_does_not_force_the_viewport_width_to_match_the_canvas
+    assert_tk_app("x: true should leave the viewport free to be wider than the canvas, for horizontal scrolling") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.scrollable(:region, x: true) { |s| s.column(:rows) { |c| c.button(text: 'Row') } }
+      end
+      session.run_async
+      session.app.update
+
+      canvas_path = "#{session[:region].path}.canvas"
+      assert_equal '', session.app.tcl_eval("bind #{canvas_path} <Configure>"),
+        "no width-sync binding should be wired when x: true"
+
+      session.app.destroy
+    end
+  end
+
+  def test_participates_in_normal_layout_like_any_other_container
+    assert_tk_app("a scrollable nested in a column with grow: true should realize and map without error") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.column do |c|
+          c.label(text: 'Header')
+          c.scrollable(:region, grow: true) { |s| s.checkbox(text: 'A checkbox') }
+        end
+      end
+      session.run_async
+      session.app.update
+
+      assert session.app.winfo.ismapped?(session[:region].path)
+
+      session.app.destroy
+    end
+  end
+
+  def test_no_widget_in_the_subtree_has_conflicting_geometry_managers
+    assert_tk_app("grid (region) and pack (viewport content) must never collide on the same master") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Test') do |ui|
+        ui.scrollable(:region_a) { |s| s.column { |c| c.button(text: 'A') } }
+        ui.scrollable(:region_b, x: true) { |s| s.row { |r| r.button(text: 'B') } }
+      end
+      session.run_async
+      session.app.update
+
+      check = lambda do |path|
+        children = session.app.split_list(session.app.tcl_eval("winfo children #{path}"))
+        managers = children.map { |child| session.app.tcl_eval("winfo manager #{child}") }.reject(&:empty?).uniq
+        assert_operator managers.length, :<=, 1,
+          "#{path} has children managed by more than one geometry manager: #{managers.inspect}"
+        children.each { |child| check.call(child) }
+      end
+      check.call('.')
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_scrollable_wheel.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# create_scrollable wires the scrollbar and scrollregion sync (see
+# test_scrollable.rb), but the frame case's canvas + embedded viewport has
+# no wheel handling of its own - a bare canvas doesn't respond to
+# <MouseWheel>, and neither do arbitrary widgets nested inside it. These
+# confirm the fix: a shared bindtag (see Realizer#wire_wheel_scroll)
+# applied to the canvas, the viewport, and everything already inside it,
+# so wheeling over any of them scrolls the same region - and that a
+# widget with no such tag is left alone.
+#
+# yview/xview reading is inlined as a local lambda in every block (not a
+# helper method) - assert_tk_app re-evaluates each block's own source text
+# in a separate worker process, which has no access to methods defined on
+# this class.
+class TestScrollableWheel < Minitest::Test
+  include TeekTestHelper
+
+  def test_wheel_over_the_canvas_scrolls_the_frame_case
+    assert_tk_app("MouseWheel over the canvas itself should scroll it") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Wheel Test') do |ui|
+        ui.scrollable(:region) { |s| s.column { |c| 30.times { |i| c.button(text: "Row #{i}") } } }
+      end
+      session.run_async
+      session.app.update
+      session.app.update_idletasks
+
+      canvas_path = "#{session[:region].path}.canvas"
+      yview_first = -> { session.app.tcl_eval("#{canvas_path} yview").split.first.to_f }
+      assert_equal 0.0, yview_first.call
+
+      session.app.tcl_eval("event generate #{canvas_path} <MouseWheel> -delta -120")
+      session.app.update
+
+      assert_operator yview_first.call, :>, 0.0
+
+      session.app.destroy
+    end
+  end
+
+  def test_wheel_over_a_nested_widget_also_scrolls_the_region
+    assert_tk_app("MouseWheel over a widget nested deep inside the viewport should still scroll the canvas") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Wheel Test') do |ui|
+        ui.scrollable(:region) do |s|
+          s.column { |c| 30.times { |i| c.button("row_#{i}".to_sym, text: "Row #{i}") } }
+        end
+      end
+      session.run_async
+      session.app.update
+      session.app.update_idletasks
+
+      canvas_path = "#{session[:region].path}.canvas"
+      nested_button_path = session[:row_5].path
+      yview_first = -> { session.app.tcl_eval("#{canvas_path} yview").split.first.to_f }
+
+      session.app.tcl_eval("event generate #{nested_button_path} <MouseWheel> -delta -120")
+      session.app.update
+
+      assert_operator yview_first.call, :>, 0.0
+
+      session.app.destroy
+    end
+  end
+
+  def test_wheel_over_an_unrelated_widget_does_not_scroll_the_region
+    assert_tk_app("MouseWheel over a widget with no bindtag from the scrollable region should leave it alone") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Wheel Test') do |ui|
+        ui.scrollable(:region) { |s| s.column { |c| 30.times { |i| c.button(text: "Row #{i}") } } }
+        ui.button(:elsewhere, text: 'Elsewhere')
+      end
+      session.run_async
+      session.app.update
+      session.app.update_idletasks
+
+      canvas_path = "#{session[:region].path}.canvas"
+      yview_first = -> { session.app.tcl_eval("#{canvas_path} yview").split.first.to_f }
+
+      session.app.tcl_eval("event generate #{session[:elsewhere].path} <MouseWheel> -delta -120")
+      session.app.update
+
+      assert_equal 0.0, yview_first.call
+
+      session.app.destroy
+    end
+  end
+
+  def test_button_4_and_5_also_scroll_the_frame_case
+    assert_tk_app("the X11 Button-4/Button-5 wheel fallback should scroll the region too") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Wheel Test') do |ui|
+        ui.scrollable(:region) { |s| s.column { |c| 30.times { |i| c.button(text: "Row #{i}") } } }
+      end
+      session.run_async
+      session.app.update
+      session.app.update_idletasks
+
+      canvas_path = "#{session[:region].path}.canvas"
+      yview_first = -> { session.app.tcl_eval("#{canvas_path} yview").split.first.to_f }
+
+      session.app.tcl_eval("event generate #{canvas_path} <Button-5>")
+      session.app.update
+      after_down = yview_first.call
+      assert_operator after_down, :>, 0.0
+
+      session.app.tcl_eval("event generate #{canvas_path} <Button-4>")
+      session.app.update
+      assert_operator yview_first.call, :<, after_down
+
+      session.app.destroy
+    end
+  end
+
+  def test_shift_mouse_wheel_scrolls_horizontally_when_x_is_enabled
+    assert_tk_app("Shift-MouseWheel should drive xview when x: true") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Wheel Test') do |ui|
+        ui.scrollable(:region, x: true) { |s| s.row { |r| 30.times { |i| r.button(text: "Col #{i}") } } }
+      end
+      session.run_async
+      session.app.update
+      session.app.update_idletasks
+
+      canvas_path = "#{session[:region].path}.canvas"
+      xview_first = -> { session.app.tcl_eval("#{canvas_path} xview").split.first.to_f }
+      assert_equal 0.0, xview_first.call
+
+      session.app.tcl_eval("event generate #{canvas_path} <Shift-MouseWheel> -delta -120")
+      session.app.update
+
+      assert_operator xview_first.call, :>, 0.0
+
+      session.app.destroy
+    end
+  end
+
+  def test_native_scrollable_widget_wheel_scrolls_through_the_dsl
+    assert_tk_app("MouseWheel over a native scrollable widget (Tk's own class binding) should work through the DSL") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Scrollable Wheel Test') do |ui|
+        ui.scrollable(:region) { |s| s.list(:items, height: 5) }
+      end
+      session.run_async
+      session.app.update
+
+      list_path = session[:items].path
+      session.app.command(list_path, :insert, :end, *(1..60).map { |i| "Item #{i}" })
+      session.app.update_idletasks
+
+      yview_first = -> { session.app.tcl_eval("#{list_path} yview").split.first.to_f }
+      assert_equal 0.0, yview_first.call
+
+      session.app.tcl_eval("event generate #{list_path} <MouseWheel> -delta -120")
+      session.app.update
+
+      assert_operator yview_first.call, :>, 0.0
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_scrollbar_auto_hide.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# wire_scrollbars wires -yscrollcommand/-xscrollcommand through
+# Realizer#auto_hide_scrollbar instead of a plain literal string, so a
+# scrollbar is grid-removed (not just left dangling and useless) whenever
+# its content fully fits, and re-shown the moment it doesn't - real
+# "overflow: auto" rather than a bar that's always there whether it's
+# needed or not. Shared by both the native-widget auto-attach path and
+# ui.scrollable's own frame case, so a couple of each is enough to prove
+# the one underlying mechanism.
+#
+# The initial hide/show state settles via an #after_idle check (see
+# Realizer#auto_hide_scrollbar's own comment - Tk only re-invokes
+# -yscrollcommand on an actual fraction *change*, so an empty widget
+# gaining a few rows never fires it on its own). A single
+# +update_idletasks+ isn't reliably enough to flush that under Xvfb - this
+# project has hit that class of timing gap before (see
+# TeekTestHelper#wait_until's other callers) - so the mapped/unmapped
+# assertions below poll for it instead of asserting immediately after one
+# idle flush.
+class TestScrollbarAutoHide < Minitest::Test
+  include TeekTestHelper
+
+  def test_scrollbar_is_hidden_when_content_fits
+    assert_tk_app("a scrollbar should be grid-removed when its content doesn't overflow the visible area") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Auto-Hide Test') { |ui| ui.list(:items, height: 10) }
+      session.run_async
+      session.app.command(session[:items].path, :insert, :end, 'one', 'two', 'three')
+
+      wrapper = session[:items].path.sub(/\.widget\z/, '')
+      assert_equal '1', session.app.tcl_eval("winfo exists #{wrapper}.vsb"), "the scrollbar widget itself still exists"
+      assert wait_until { !session.app.winfo.ismapped?("#{wrapper}.vsb") },
+        "should be grid-removed once idle processing settles, since everything fits"
+
+      session.app.destroy
+    end
+  end
+
+  def test_scrollbar_is_shown_when_content_overflows
+    assert_tk_app("a scrollbar should be mapped once its content overflows the visible area") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Auto-Hide Test') { |ui| ui.list(:items, height: 5) }
+      session.run_async
+      session.app.command(session[:items].path, :insert, :end, *(1..50).map { |i| "Item #{i}" })
+
+      wrapper = session[:items].path.sub(/\.widget\z/, '')
+      assert wait_until { session.app.winfo.ismapped?("#{wrapper}.vsb") }
+
+      session.app.destroy
+    end
+  end
+
+  def test_scrollbar_appears_once_content_grows_past_fitting
+    assert_tk_app("a scrollbar hidden at realize should reappear once enough content is added later") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Auto-Hide Test') { |ui| ui.list(:items, height: 5) }
+      session.run_async
+      session.app.command(session[:items].path, :insert, :end, 'one', 'two')
+
+      wrapper = session[:items].path.sub(/\.widget\z/, '')
+      assert wait_until { !session.app.winfo.ismapped?("#{wrapper}.vsb") }, "should start hidden with only 2 items"
+
+      session.app.command(session[:items].path, :insert, :end, *(1..50).map { |i| "More #{i}" })
+
+      assert wait_until { session.app.winfo.ismapped?("#{wrapper}.vsb") }, "should reappear once content overflows"
+
+      session.app.destroy
+    end
+  end
+
+  def test_scrollbar_disappears_again_once_content_shrinks_back_to_fitting
+    assert_tk_app("a visible scrollbar should hide again once enough content is removed") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Auto-Hide Test') { |ui| ui.list(:items, height: 5) }
+      session.run_async
+      session.app.command(session[:items].path, :insert, :end, *(1..50).map { |i| "Item #{i}" })
+
+      wrapper = session[:items].path.sub(/\.widget\z/, '')
+      assert wait_until { session.app.winfo.ismapped?("#{wrapper}.vsb") }, "should start shown with 50 items"
+
+      session.app.command(session[:items].path, :delete, 2, :end)
+
+      assert wait_until { !session.app.winfo.ismapped?("#{wrapper}.vsb") }, "should hide again once only 2 items remain"
+
+      session.app.destroy
+    end
+  end
+
+  def test_the_frame_case_also_auto_hides_its_scrollbar
+    assert_tk_app("ui.scrollable's own canvas-driven scrollbar should auto-hide the same way") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Auto-Hide Test') do |ui|
+        ui.scrollable(:region) { |s| s.column(:rows) { |c| c.button(text: 'One lone button') } }
+      end
+      session.run_async
+
+      assert wait_until { !session.app.winfo.ismapped?("#{session[:region].path}.vsb") },
+        "one small button shouldn't overflow the canvas's own default size"
+
+      session.app.destroy
+    end
+  end
+
+  def test_the_frame_case_shows_its_scrollbar_once_content_overflows
+    assert_tk_app("ui.scrollable's canvas-driven scrollbar should appear once its content overflows") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Auto-Hide Test') do |ui|
+        ui.scrollable(:region) { |s| s.column(:rows) { |c| 40.times { |i| c.button(text: "Row #{i}") } } }
+      end
+      session.run_async
+
+      assert wait_until { session.app.winfo.ismapped?("#{session[:region].path}.vsb") }
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_split.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# ui.split/s.pane realize as a working ttk::panedwindow - each pane a real
+# Tk frame added as a managed pane (PaneRealize.post_create), never
+# pack/grid managed on its own (:pane's own arranged: false).
+class TestSplit < Minitest::Test
+  include TeekTestHelper
+
+  def test_split_realizes_as_a_working_panedwindow_with_panes
+    assert_tk_app("ui.split should realize as a ttk::panedwindow with each pane added as a managed region") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Split Test') do |ui|
+        ui.split(:s) do |s|
+          s.pane { |a| a.button(:go, text: 'Go') }
+          s.pane { |b| b.label(:info, text: 'Info') }
+        end
+      end
+      session.run_async
+      session.app.update
+
+      split_path = session[:s].path
+      pane_paths = session.app.split_list(session.app.command(split_path, :panes))
+      assert_equal 2, pane_paths.length
+
+      session.app.destroy
+    end
+  end
+
+  def test_pane_content_is_addressable_and_configurable_like_any_other_widget
+    assert_tk_app("a widget declared inside a pane should be a normal, addressable, configurable widget") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Split Test') do |ui|
+        ui.split { |s| s.pane { |a| a.button(:go, text: 'Go') } }
+      end
+      session.run_async
+      session.app.update
+
+      session[:go].configure(text: 'Changed')
+      session.app.update
+
+      assert_equal 'Changed', session.app.command(session[:go].path, :cget, '-text')
+
+      session.app.destroy
+    end
+  end
+
+  def test_pane_frame_is_not_independently_pack_or_grid_managed
+    assert_tk_app("a pane's own frame should be placed only by panedwindow add, not pack/grid") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Split Test') do |ui|
+        ui.split(:s) { |s| s.pane(:left) { |a| a.button(text: 'Go') } }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal 'panedwindow', session.app.tcl_eval("winfo manager #{session[:left].path}"),
+        "the panedwindow itself should be the only geometry manager - proves no pack/grid call also ran"
+
+      session.app.destroy
+    end
+  end
+
+  def test_split_defaults_to_horizontal_orientation
+    assert_tk_app("ui.split with no orientation given should realize with -orient horizontal") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Split Test') do |ui|
+        ui.split(:s) { |s| s.pane { } }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal 'horizontal', session.app.command(session[:s].path, :cget, '-orient')
+
+      session.app.destroy
+    end
+  end
+
+  def test_split_vertical_orientation_sets_the_real_tk_orient_option
+    assert_tk_app("ui.split(orientation: :vertical) should realize with -orient vertical") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Split Test') do |ui|
+        ui.split(:s, orientation: :vertical) { |s| s.pane { } }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal 'vertical', session.app.command(session[:s].path, :cget, '-orient')
+
+      session.app.destroy
+    end
+  end
+
+  def test_pane_weight_is_passed_through_to_panedwindow_add
+    assert_tk_app("s.pane(weight:) should set the real -weight panedwindow uses to divide leftover space") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Split Test') do |ui|
+        ui.split(:s) do |s|
+          s.pane(:left, weight: 1) { }
+          s.pane(:right, weight: 3) { }
+        end
+      end
+      session.run_async
+      session.app.update
+
+      split_path = session[:s].path
+      assert_equal '1', session.app.command(split_path, :pane, session[:left].path, '-weight')
+      assert_equal '3', session.app.command(split_path, :pane, session[:right].path, '-weight')
+
+      session.app.destroy
+    end
+  end
+
+  def test_a_new_pane_can_be_added_at_runtime_via_incremental_realize
+    assert_tk_app("session.add should be able to add a whole new pane to an already-realized ui.split") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Split Test') do |ui|
+        ui.split(:s) { |s| s.pane { |a| a.button(text: 'Go') } }
+      end
+      session.run_async
+      session.app.update
+
+      split_path = session[:s].path
+      assert_equal 1, session.app.split_list(session.app.command(split_path, :panes)).length
+
+      session.add(:s) { |a| a.pane(:new_pane) { |n| n.button(:new_button, text: 'New') } }
+      session.app.update
+
+      pane_paths = session.app.split_list(session.app.command(split_path, :panes))
+      assert_equal 2, pane_paths.length
+      assert session.app.winfo.ismapped?(session[:new_button].path)
+
+      session.app.destroy
+    end
+  end
+end