Split integration test file (#4205)

19 files changed, 4622 insertions, 4519 deletions

diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
index e4117238..7e58bb49 100644
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -30,19 +30,19 @@ jobs:
     - name: Setup Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.1.0
+        ruby-version: 3.4.1
 
     - name: Install packages
       run: sudo apt-get install --yes zsh fish tmux
 
     - name: Install Ruby gems
-      run: sudo gem install --no-document minitest:5.25.1 rubocop:1.65.0 rubocop-minitest:0.35.1 rubocop-performance:1.21.1
+      run: bundle install
 
     - name: Rubocop
-      run: rubocop --require rubocop-minitest --require rubocop-performance
+      run: make lint
 
     - name: Unit test
       run: make test
 
     - name: Integration test
-      run: make install && ./install --all && tmux new-session -d && ruby test/test_go.rb --verbose
+      run: make install && ./install --all && tmux new-session -d && ruby test/runner.rb --verbose
diff --git a/.gitignore b/.gitignore
index 8bde085a..40b2b4e4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,6 @@ bin/fzf.exe
 dist
 target
 pkg
-Gemfile.lock
 .DS_Store
 doc/tags
 vendor
diff --git a/.rubocop.yml b/.rubocop.yml
index 28d8a340..920c1e5c 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,3 +1,5 @@
+AllCops:
+  NewCops: enable
 Layout/LineLength:
   Enabled: false
 Metrics:
@@ -28,5 +30,11 @@ Style/WordArray:
   MinSize: 1
 Minitest/AssertEqual:
   Enabled: false
+Minitest/EmptyLineBeforeAssertionMethods:
+  Enabled: false
 Naming/VariableNumber:
   Enabled: false
+Lint/EmptyBlock:
+  Enabled: false
+Style/SafeNavigationChainLength:
+  Enabled: false
diff --git a/.tool-versions b/.tool-versions
index ccba328f..2b8daa05 100644
--- a/.tool-versions
+++ b/.tool-versions
@@ -1 +1,2 @@
 golang 1.20.13
+ruby 3.4.1
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 00000000..f2be6170
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'minitest', '5.25.4'
+gem 'rubocop', '1.71.0'
+gem 'rubocop-minitest', '0.36.0'
+gem 'rubocop-performance', '1.23.1'
diff --git a/Gemfile.lock b/Gemfile.lock
new file mode 100644
index 00000000..30bba132
--- /dev/null
+++ b/Gemfile.lock
@@ -0,0 +1,47 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    json (2.9.1)
+    language_server-protocol (3.17.0.3)
+    minitest (5.25.4)
+    parallel (1.26.3)
+    parser (3.3.7.0)
+      ast (~> 2.4.1)
+      racc
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.10.0)
+    rubocop (1.71.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.36.2, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.37.0)
+      parser (>= 3.3.1.0)
+    rubocop-minitest (0.36.0)
+      rubocop (>= 1.61, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    rubocop-performance (1.23.1)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (2.6.0)
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+  minitest (= 5.25.4)
+  rubocop (= 1.71.0)
+  rubocop-minitest (= 0.36.0)
+  rubocop-performance (= 1.23.1)
+
+BUNDLED WITH
+   2.6.2
diff --git a/Makefile b/Makefile
index ea565a0a..d66d2ef8 100644
--- a/Makefile
+++ b/Makefile
@@ -82,12 +82,15 @@ test: $(SOURCES)
 				github.com/junegunn/fzf/src/tui \
 				github.com/junegunn/fzf/src/util
 
+itest:
+	ruby test/runner.rb
+
 bench:
 	cd src && SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" -run=Bench -bench=. -benchmem
 
-lint: $(SOURCES) test/test_go.rb
+lint: $(SOURCES) test/*.rb test/lib/*.rb
 	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
-	rubocop --require rubocop-minitest --require rubocop-performance
+	bundle exec rubocop -a --require rubocop-minitest --require rubocop-performance
 
 install: bin/fzf
 
@@ -186,4 +189,4 @@ update:
 	$(GO) get -u
 	$(GO) mod tidy
 
-.PHONY: all generate build release test bench lint install clean docker docker-test update
+.PHONY: all generate build release test itest bench lint install clean docker docker-test update
diff --git a/test/lib/common.rb b/test/lib/common.rb
new file mode 100644
index 00000000..ec8b05e9
--- /dev/null
+++ b/test/lib/common.rb
@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'fileutils'
+require 'English'
+require 'shellwords'
+require 'erb'
+require 'tempfile'
+require 'net/http'
+require 'json'
+
+TEMPLATE = File.read(File.expand_path('common.sh', __dir__))
+UNSETS = %w[
+  FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS
+  FZF_TMUX FZF_TMUX_OPTS
+  FZF_CTRL_T_COMMAND FZF_CTRL_T_OPTS
+  FZF_ALT_C_COMMAND
+  FZF_ALT_C_OPTS FZF_CTRL_R_OPTS
+  FZF_API_KEY
+].freeze
+DEFAULT_TIMEOUT = 10
+
+FILE = File.expand_path(__FILE__)
+BASE = File.expand_path('../..', __dir__)
+Dir.chdir(BASE)
+FZF = "FZF_DEFAULT_OPTS=\"--no-scrollbar --pointer \\> --marker \\>\" FZF_DEFAULT_COMMAND= #{BASE}/bin/fzf".freeze
+
+def wait(timeout = DEFAULT_TIMEOUT)
+  since = Time.now
+  begin
+    yield or raise Minitest::Assertion, 'Assertion failure'
+  rescue Minitest::Assertion
+    raise if Time.now - since > timeout
+
+    sleep(0.05)
+    retry
+  end
+end
+
+class Shell
+  class << self
+    def bash
+      @bash ||=
+        begin
+          bashrc = '/tmp/fzf.bash'
+          File.open(bashrc, 'w') do |f|
+            f.puts ERB.new(TEMPLATE).result(binding)
+          end
+
+          "bash --rcfile #{bashrc}"
+        end
+    end
+
+    def zsh
+      @zsh ||=
+        begin
+          zdotdir = '/tmp/fzf-zsh'
+          FileUtils.rm_rf(zdotdir)
+          FileUtils.mkdir_p(zdotdir)
+          File.open("#{zdotdir}/.zshrc", 'w') do |f|
+            f.puts ERB.new(TEMPLATE).result(binding)
+          end
+          "ZDOTDIR=#{zdotdir} zsh"
+        end
+    end
+
+    def fish
+      "unset #{UNSETS.join(' ')}; rm -f ~/.local/share/fish/fzf_test_history; FZF_DEFAULT_OPTS=\"--no-scrollbar --pointer '>' --marker '>'\" fish_history=fzf_test fish"
+    end
+  end
+end
+
+class Tmux
+  attr_reader :win
+
+  def initialize(shell = :bash)
+    @win = go(%W[new-window -d -P -F #I #{Shell.send(shell)}]).first
+    go(%W[set-window-option -t #{@win} pane-base-index 0])
+    return unless shell == :fish
+
+    send_keys 'function fish_prompt; end; clear', :Enter
+    self.until(&:empty?)
+  end
+
+  def kill
+    go(%W[kill-window -t #{win}])
+  end
+
+  def focus
+    go(%W[select-window -t #{win}])
+  end
+
+  def send_keys(*args)
+    go(%W[send-keys -t #{win}] + args.map(&:to_s))
+  end
+
+  def paste(str)
+    system('tmux', 'setb', str, ';', 'pasteb', '-t', win, ';', 'send-keys', '-t', win, 'Enter')
+  end
+
+  def capture
+    go(%W[capture-pane -p -J -t #{win}]).map(&:rstrip).reverse.drop_while(&:empty?).reverse
+  end
+
+  def until(refresh = false, timeout: DEFAULT_TIMEOUT)
+    lines = nil
+    begin
+      wait(timeout) do
+        lines = capture
+        class << lines
+          def counts
+            lazy
+              .map { |l| l.scan(%r{^. ([0-9]+)/([0-9]+)( \(([0-9]+)\))?}) }
+              .reject(&:empty?)
+              .first&.first&.map(&:to_i)&.values_at(0, 1, 3) || [0, 0, 0]
+          end
+
+          def match_count
+            counts[0]
+          end
+
+          def item_count
+            counts[1]
+          end
+
+          def select_count
+            counts[2]
+          end
+
+          def any_include?(val)
+            method = val.is_a?(Regexp) ? :match : :include?
+            find { |line| line.send(method, val) }
+          end
+        end
+        yield(lines).tap do |ok|
+          send_keys 'C-l' if refresh && !ok
+        end
+      end
+    rescue Minitest::Assertion
+      puts $ERROR_INFO.backtrace
+      puts '>' * 80
+      puts lines
+      puts '<' * 80
+      raise
+    end
+    lines
+  end
+
+  def prepare
+    tries = 0
+    begin
+      self.until(true) do |lines|
+        message = "Prepare[#{tries}]"
+        send_keys ' ', 'C-u', :Enter, message, :Left, :Right
+        lines[-1] == message
+      end
+    rescue Minitest::Assertion
+      (tries += 1) < 5 ? retry : raise
+    end
+    send_keys 'C-u', 'C-l'
+  end
+
+  private
+
+  def go(args)
+    IO.popen(%w[tmux] + args) { |io| io.readlines(chomp: true) }
+  end
+end
+
+class TestBase < Minitest::Test
+  TEMPNAME = Dir::Tmpname.create(%w[fzf]) {}
+  FIFONAME = Dir::Tmpname.create(%w[fzf-fifo]) {}
+
+  def writelines(lines)
+    File.write(TEMPNAME, lines.join("\n"))
+  end
+
+  def tempname
+    TEMPNAME
+  end
+
+  def fzf_output
+    @thread.join.value.chomp.tap { @thread = nil }
+  end
+
+  def fzf_output_lines
+    fzf_output.lines(chomp: true)
+  end
+
+  def setup
+    File.mkfifo(FIFONAME)
+  end
+
+  def teardown
+    FileUtils.rm_f([TEMPNAME, FIFONAME])
+  end
+
+  alias assert_equal_org assert_equal
+  def assert_equal(expected, actual)
+    # Ignore info separator
+    actual = actual&.sub(/\s*─+$/, '') if actual.is_a?(String) && actual&.match?(%r{\d+/\d+})
+    assert_equal_org(expected, actual)
+  end
+
+  # Run fzf with its output piped to a fifo
+  def fzf(*opts)
+    raise 'fzf_output not taken' if @thread
+
+    @thread = Thread.new { File.read(FIFONAME) }
+    fzf!(*opts) + " > #{FIFONAME.shellescape}"
+  end
+
+  def fzf!(*opts)
+    opts = opts.filter_map do |o|
+      case o
+      when Symbol
+        o = o.to_s
+        o.length > 1 ? "--#{o.tr('_', '-')}" : "-#{o}"
+      when String, Numeric
+        o.to_s
+      end
+    end
+    "#{FZF} #{opts.join(' ')}"
+  end
+end
+
+class TestInteractive < TestBase
+  attr_reader :tmux
+
+  def setup
+    super
+    @tmux = Tmux.new
+  end
+
+  def teardown
+    super
+    @tmux.kill
+  end
+end
diff --git a/test/lib/common.sh b/test/lib/common.sh
new file mode 100644
index 00000000..44d03622
--- /dev/null
+++ b/test/lib/common.sh
@@ -0,0 +1,59 @@
+set -u
+PS1= PROMPT_COMMAND= HISTFILE= HISTSIZE=100
+unset <%= UNSETS.join(' ') %>
+unset $(env | sed -n /^_fzf_orig/s/=.*//p)
+unset $(declare -F | sed -n "/_fzf/s/.*-f //p")
+
+export FZF_DEFAULT_OPTS="--no-scrollbar --pointer '>' --marker '>'"
+
+# Setup fzf
+# ---------
+if [[ ! "$PATH" == *<%= BASE %>/bin* ]]; then
+  export PATH="${PATH:+${PATH}:}<%= BASE %>/bin"
+fi
+
+# Auto-completion
+# ---------------
+[[ $- == *i* ]] && source "<%= BASE %>/shell/completion.<%= __method__ %>" 2> /dev/null
+
+# Key bindings
+# ------------
+source "<%= BASE %>/shell/key-bindings.<%= __method__ %>"
+
+# Old API
+_fzf_complete_f() {
+  _fzf_complete "+m --multi --prompt \"prompt-f> \"" "$@" < <(
+    echo foo
+    echo bar
+  )
+}
+
+# New API
+_fzf_complete_g() {
+  _fzf_complete +m --multi --prompt "prompt-g> " -- "$@" < <(
+    echo foo
+    echo bar
+  )
+}
+
+_fzf_complete_f_post() {
+  awk '{print "f" $0 $0}'
+}
+
+_fzf_complete_g_post() {
+  awk '{print "g" $0 $0}'
+}
+
+[ -n "${BASH-}" ] && complete -F _fzf_complete_f -o default -o bashdefault f
+[ -n "${BASH-}" ] && complete -F _fzf_complete_g -o default -o bashdefault g
+
+_comprun() {
+  local command=$1
+  shift
+
+  case "$command" in
+    f) fzf "$@" --preview 'echo preview-f-{}' ;;
+    g) fzf "$@" --preview 'echo preview-g-{}' ;;
+    *) fzf "$@" ;;
+  esac
+}
diff --git a/test/runner.rb b/test/runner.rb
new file mode 100644
index 00000000..ecc40e98
--- /dev/null
+++ b/test/runner.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'test_*.rb')].each { require it }
+
+require 'minitest/autorun'
diff --git a/test/test_core.rb b/test/test_core.rb
new file mode 100644
index 00000000..1524a885
--- /dev/null
+++ b/test/test_core.rb
@@ -0,0 +1,1588 @@
+# frozen_string_literal: true
+
+require_relative 'lib/common'
+
+# Testing basic features of fzf
+class TestCore < TestInteractive
+  def test_fzf_default_command
+    tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND='echo hello'"), :Enter
+    tmux.until { |lines| assert_equal '> hello', lines[-3] }
+
+    tmux.send_keys :Enter
+    assert_equal 'hello', fzf_output
+  end
+
+  def test_fzf_default_command_failure
+    tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', 'FZF_DEFAULT_COMMAND=false'), :Enter
+    tmux.until { |lines| assert_includes lines[-2], '  [Command failed: false] ─' }
+    tmux.send_keys :Enter
+  end
+
+  def test_key_bindings
+    tmux.send_keys "#{FZF} -q 'foo bar foo-bar'", :Enter
+    tmux.until { |lines| assert_equal '> foo bar foo-bar', lines.last }
+
+    # CTRL-A
+    tmux.send_keys 'C-A', '('
+    tmux.until { |lines| assert_equal '> (foo bar foo-bar', lines.last }
+
+    # META-F
+    tmux.send_keys :Escape, :f, ')'
+    tmux.until { |lines| assert_equal '> (foo) bar foo-bar', lines.last }
+
+    # CTRL-B
+    tmux.send_keys 'C-B', 'var'
+    tmux.until { |lines| assert_equal '> (foovar) bar foo-bar', lines.last }
+
+    # Left, CTRL-D
+    tmux.send_keys :Left, :Left, 'C-D'
+    tmux.until { |lines| assert_equal '> (foovr) bar foo-bar', lines.last }
+
+    # META-BS
+    tmux.send_keys :Escape, :BSpace
+    tmux.until { |lines| assert_equal '> (r) bar foo-bar', lines.last }
+
+    # CTRL-Y
+    tmux.send_keys 'C-Y', 'C-Y'
+    tmux.until { |lines| assert_equal '> (foovfoovr) bar foo-bar', lines.last }
+
+    # META-B
+    tmux.send_keys :Escape, :b, :Space, :Space
+    tmux.until { |lines| assert_equal '> (  foovfoovr) bar foo-bar', lines.last }
+
+    # CTRL-F / Right
+    tmux.send_keys 'C-F', :Right, '/'
+    tmux.until { |lines| assert_equal '> (  fo/ovfoovr) bar foo-bar', lines.last }
+
+    # CTRL-H / BS
+    tmux.send_keys 'C-H', :BSpace
+    tmux.until { |lines| assert_equal '> (  fovfoovr) bar foo-bar', lines.last }
+
+    # CTRL-E
+    tmux.send_keys 'C-E', 'baz'
+    tmux.until { |lines| assert_equal '> (  fovfoovr) bar foo-barbaz', lines.last }
+
+    # CTRL-U
+    tmux.send_keys 'C-U'
+    tmux.until { |lines| assert_equal '>', lines.last }
+
+    # CTRL-Y
+    tmux.send_keys 'C-Y'
+    tmux.until { |lines| assert_equal '> (  fovfoovr) bar foo-barbaz', lines.last }
+
+    # CTRL-W
+    tmux.send_keys 'C-W', 'bar-foo'
+    tmux.until { |lines| assert_equal '> (  fovfoovr) bar bar-foo', lines.last }
+
+    # META-D
+    tmux.send_keys :Escape, :b, :Escape, :b, :Escape, :d, 'C-A', 'C-Y'
+    tmux.until { |lines| assert_equal '> bar(  fovfoovr) bar -foo', lines.last }
+
+    # CTRL-M
+    tmux.send_keys 'C-M'
+    tmux.until { |lines| refute_equal '>', lines.last }
+  end
+
+  def test_file_word
+    tmux.send_keys "#{FZF} -q '--/foo bar/foo-bar/baz' --filepath-word", :Enter
+    tmux.until { |lines| assert_equal '> --/foo bar/foo-bar/baz', lines.last }
+
+    tmux.send_keys :Escape, :b
+    tmux.send_keys :Escape, :b
+    tmux.send_keys :Escape, :b
+    tmux.send_keys :Escape, :d
+    tmux.send_keys :Escape, :f
+    tmux.send_keys :Escape, :BSpace
+    tmux.until { |lines| assert_equal '> --///baz', lines.last }
+  end
+
+  def test_multi_order
+    tmux.send_keys "seq 1 10 | #{fzf(:multi)}", :Enter
+    tmux.until { |lines| assert_equal '>', lines.last }
+
+    tmux.send_keys :Tab, :Up, :Up, :Tab, :Tab, :Tab, # 3, 2
+                   'C-K', 'C-K', 'C-K', 'C-K', :BTab, :BTab, # 5, 6
+                   :PgUp, 'C-J', :Down, :Tab, :Tab # 8, 7
+    tmux.until { |lines| assert_equal '  10/10 (6)', lines[-2] }
+    tmux.send_keys 'C-M'
+    assert_equal %w[3 2 5 6 8 7], fzf_output_lines
+  end
+
+  def test_multi_max
+    tmux.send_keys "seq 1 10 | #{FZF} -m 3 --bind A:select-all,T:toggle-all --preview 'echo [{+}]/{}'", :Enter
+
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+
+    tmux.send_keys '1'
+    tmux.until do |lines|
+      assert_includes lines[1], ' [1]/1 '
+      assert lines[-2]&.start_with?('  2/10 ')
+    end
+
+    tmux.send_keys 'A'
+    tmux.until do |lines|
+      assert_includes lines[1], ' [1 10]/1 '
+      assert lines[-2]&.start_with?('  2/10 (2/3)')
+    end
+
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (2/3)') }
+
+    tmux.send_keys 'T'
+    tmux.until do |lines|
+      assert_includes lines[1], ' [2 3 4]/1 '
+      assert lines[-2]&.start_with?('  10/10 (3/3)')
+    end
+
+    %w[T A].each do |key|
+      tmux.send_keys key
+      tmux.until do |lines|
+        assert_includes lines[1], ' [1 5 6]/1 '
+        assert lines[-2]&.start_with?('  10/10 (3/3)')
+      end
+    end
+
+    tmux.send_keys :BTab
+    tmux.until do |lines|
+      assert_includes lines[1], ' [5 6]/2 '
+      assert lines[-2]&.start_with?('  10/10 (2/3)')
+    end
+
+    [:BTab, :BTab, 'A'].each do |key|
+      tmux.send_keys key
+      tmux.until do |lines|
+        assert_includes lines[1], ' [5 6 2]/3 '
+        assert lines[-2]&.start_with?('  10/10 (3/3)')
+      end
+    end
+
+    tmux.send_keys '2'
+    tmux.until { |lines| assert lines[-2]&.start_with?('  1/10 (3/3)') }
+
+    tmux.send_keys 'T'
+    tmux.until do |lines|
+      assert_includes lines[1], ' [5 6]/2 '
+      assert lines[-2]&.start_with?('  1/10 (2/3)')
+    end
+
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (2/3)') }
+
+    tmux.send_keys 'A'
+    tmux.until do |lines|
+      assert_includes lines[1], ' [5 6 1]/1 '
+      assert lines[-2]&.start_with?('  10/10 (3/3)')
+    end
+  end
+
+  def test_multi_action
+    tmux.send_keys "seq 10 | #{FZF} --bind 'a:change-multi,b:change-multi(3),c:change-multi(xxx),d:change-multi(0)'", :Enter
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 ') }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (0)') }
+    tmux.send_keys 'b'
+    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (0/3)') }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (1/3)') }
+    tmux.send_keys 'c'
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (2/3)') }
+    tmux.send_keys 'd'
+    tmux.until do |lines|
+      assert lines[-2]&.start_with?('  10/10 ') && !lines[-2]&.include?('(')
+    end
+  end
+
+  def test_with_nth
+    [true, false].each do |multi|
+      tmux.send_keys "(echo '  1st 2nd 3rd/';
+                       echo '  first second third/') |
+                       #{fzf(multi && :multi, :x, :nth, 2, :with_nth, '2,-1,1')}",
+                     :Enter
+      tmux.until { |lines| assert_equal multi ? '  2/2 (0)' : '  2/2', lines[-2] }
+
+      # Transformed list
+      lines = tmux.capture
+      assert_equal '  second third/first', lines[-4]
+      assert_equal '> 2nd 3rd/1st',        lines[-3]
+
+      # However, the output must not be transformed
+      if multi
+        tmux.send_keys :BTab, :BTab
+        tmux.until { |lines| assert_equal '  2/2 (2)', lines[-2] }
+        tmux.send_keys :Enter
+        assert_equal ['  1st 2nd 3rd/', '  first second third/'], fzf_output_lines
+      else
+        tmux.send_keys '^', '3'
+        tmux.until { |lines| assert_equal '  1/2', lines[-2] }
+        tmux.send_keys :Enter
+        assert_equal ['  1st 2nd 3rd/'], fzf_output_lines
+      end
+    end
+  end
+
+  def test_scroll
+    [true, false].each do |rev|
+      tmux.send_keys "seq 1 100 | #{fzf(rev && :reverse)}", :Enter
+      tmux.until { |lines| assert_equal '  100/100', lines[rev ? 1 : -2] }
+      tmux.send_keys(*Array.new(110) { rev ? :Down : :Up })
+      tmux.until { |lines| assert_includes lines, '> 100' }
+      tmux.send_keys :Enter
+      assert_equal '100', fzf_output
+    end
+  end
+
+  def test_select_1
+    tmux.send_keys "seq 1 100 | #{fzf(:with_nth, '..,..', :print_query, :q, 5555, :'1')}", :Enter
+    assert_equal %w[5555 55], fzf_output_lines
+  end
+
+  def test_exit_0
+    tmux.send_keys "seq 1 100 | #{fzf(:with_nth, '..,..', :print_query, :q, 555_555, :'0')}", :Enter
+    assert_equal %w[555555], fzf_output_lines
+  end
+
+  def test_select_1_exit_0_fail
+    [:'0', :'1', %i[1 0]].each do |opt|
+      tmux.send_keys "seq 1 100 | #{fzf(:print_query, :multi, :q, 5, *opt)}", :Enter
+      tmux.until { |lines| assert_equal '> 5', lines.last }
+      tmux.send_keys :BTab, :BTab, :BTab
+      tmux.until { |lines| assert_equal '  19/100 (3)', lines[-2] }
+      tmux.send_keys :Enter
+      assert_equal %w[5 5 50 51], fzf_output_lines
+    end
+  end
+
+  def test_query_unicode
+    tmux.paste "(echo abc; echo $'\\352\\260\\200\\353\\202\\230\\353\\213\\244') | #{fzf(:query, "$'\\352\\260\\200\\353\\213\\244'")}"
+    tmux.until { |lines| assert_equal '  1/2', lines[-2] }
+    tmux.send_keys :Enter
+    assert_equal %w[가나다], fzf_output_lines
+  end
+
+  def test_sync
+    tmux.send_keys "seq 1 100 | #{FZF} --multi | awk '{print $1 $1}' | #{fzf(:sync)}", :Enter
+    tmux.until { |lines| assert_equal '>', lines[-1] }
+    tmux.send_keys 9
+    tmux.until { |lines| assert_equal '  19/100 (0)', lines[-2] }
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until { |lines| assert_equal '  19/100 (3)', lines[-2] }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal '>', lines[-1] }
+    tmux.send_keys 'C-K', :Enter
+    assert_equal %w[9090], fzf_output_lines
+  end
+
+  def test_tac
+    tmux.send_keys "seq 1 1000 | #{fzf(:tac, :multi)}", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until { |lines| assert_equal '  1000/1000 (3)', lines[-2] }
+    tmux.send_keys :Enter
+    assert_equal %w[1000 999 998], fzf_output_lines
+  end
+
+  def test_tac_sort
+    tmux.send_keys "seq 1 1000 | #{fzf(:tac, :multi)}", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys '99'
+    tmux.until { |lines| assert_equal '  28/1000 (0)', lines[-2] }
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until { |lines| assert_equal '  28/1000 (3)', lines[-2] }
+    tmux.send_keys :Enter
+    assert_equal %w[99 999 998], fzf_output_lines
+  end
+
+  def test_tac_nosort
+    tmux.send_keys "seq 1 1000 | #{fzf(:tac, :no_sort, :multi)}", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys '00'
+    tmux.until { |lines| assert_equal '  10/1000 (0)', lines[-2] }
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until { |lines| assert_equal '  10/1000 (3)', lines[-2] }
+    tmux.send_keys :Enter
+    assert_equal %w[1000 900 800], fzf_output_lines
+  end
+
+  def test_expect
+    test = lambda do |key, feed, expected = key|
+      tmux.send_keys "seq 1 100 | #{fzf(:expect, key, :prompt, "[#{key}]")}", :Enter
+      tmux.until { |lines| assert_equal '  100/100', lines[-2] }
+      tmux.send_keys '55'
+      tmux.until { |lines| assert_equal '  1/100', lines[-2] }
+      tmux.send_keys(*feed)
+      tmux.prepare
+      assert_equal [expected, '55'], fzf_output_lines
+    end
+    test.call('ctrl-t', 'C-T')
+    test.call('ctrl-t', 'Enter', '')
+    test.call('alt-c', %i[Escape c])
+    test.call('f1', 'f1')
+    test.call('f2', 'f2')
+    test.call('f3', 'f3')
+    test.call('f2,f4', 'f2', 'f2')
+    test.call('f2,f4', 'f4', 'f4')
+    test.call('alt-/', %i[Escape /])
+    %w[f5 f6 f7 f8 f9 f10].each do |key|
+      test.call('f5,f6,f7,f8,f9,f10', key, key)
+    end
+    test.call('@', '@')
+  end
+
+  def test_expect_with_bound_actions
+    tmux.send_keys "seq 1 100 | #{fzf('--query 1 --print-query --expect z --bind z:up+up')}", :Enter
+    tmux.until { |lines| assert_equal 20, lines.match_count }
+    tmux.send_keys('z')
+    assert_equal %w[1 z 1], fzf_output_lines
+  end
+
+  def test_expect_print_query
+    tmux.send_keys "seq 1 100 | #{fzf('--expect=alt-z', :print_query)}", :Enter
+    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
+    tmux.send_keys '55'
+    tmux.until { |lines| assert_equal '  1/100', lines[-2] }
+    tmux.send_keys :Escape, :z
+    assert_equal %w[55 alt-z 55], fzf_output_lines
+  end
+
+  def test_expect_printable_character_print_query
+    tmux.send_keys "seq 1 100 | #{fzf('--expect=z --print-query')}", :Enter
+    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
+    tmux.send_keys '55'
+    tmux.until { |lines| assert_equal '  1/100', lines[-2] }
+    tmux.send_keys 'z'
+    assert_equal %w[55 z 55], fzf_output_lines
+  end
+
+  def test_expect_print_query_select_1
+    tmux.send_keys "seq 1 100 | #{fzf('-q55 -1 --expect=alt-z --print-query')}", :Enter
+    assert_equal ['55', '', '55'], fzf_output_lines
+  end
+
+  def test_toggle_sort
+    ['--toggle-sort=ctrl-r', '--bind=ctrl-r:toggle-sort'].each do |opt|
+      tmux.send_keys "seq 1 111 | #{fzf("-m +s --tac #{opt} -q11")}", :Enter
+      tmux.until { |lines| assert_equal '> 111', lines[-3] }
+      tmux.send_keys :Tab
+      tmux.until { |lines| assert_equal '  4/111 -S (1)', lines[-2] }
+      tmux.send_keys 'C-R'
+      tmux.until { |lines| assert_equal '> 11', lines[-3] }
+      tmux.send_keys :Tab
+      tmux.until { |lines| assert_equal '  4/111 +S (2)', lines[-2] }
+      tmux.send_keys :Enter
+      assert_equal %w[111 11], fzf_output_lines
+    end
+  end
+
+  def test_invalid_cache
+    tmux.send_keys "(echo d; echo D; echo x) | #{fzf('-q d')}", :Enter
+    tmux.until { |lines| assert_equal '  2/3', lines[-2] }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal '  3/3', lines[-2] }
+    tmux.send_keys :D
+    tmux.until { |lines| assert_equal '  1/3', lines[-2] }
+    tmux.send_keys :Enter
+  end
+
+  def test_invalid_cache_query_type
+    command = %[(echo 'foo$bar'; echo 'barfoo'; echo 'foo^bar'; echo "foo'1-2"; seq 100) | #{FZF}]
+
+    # Suffix match
+    tmux.send_keys command, :Enter
+    tmux.until { |lines| assert_equal 104, lines.match_count }
+    tmux.send_keys 'foo$'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys 'bar'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Enter
+
+    # Prefix match
+    tmux.prepare
+    tmux.send_keys command, :Enter
+    tmux.until { |lines| assert_equal 104, lines.match_count }
+    tmux.send_keys '^bar'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys 'C-a', 'foo'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Enter
+
+    # Exact match
+    tmux.prepare
+    tmux.send_keys command, :Enter
+    tmux.until { |lines| assert_equal 104, lines.match_count }
+    tmux.send_keys "'12"
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys 'C-a', 'foo'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+  end
+
+  def test_bind
+    tmux.send_keys "seq 1 1000 | #{fzf('-m --bind=ctrl-j:accept,u:up,T:toggle-up,t:toggle')}", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys 'uuu', 'TTT', 'tt', 'uu', 'ttt', 'C-j'
+    assert_equal %w[4 5 6 9], fzf_output_lines
+  end
+
+  def test_bind_print_query
+    tmux.send_keys "seq 1 1000 | #{fzf('-m --bind=ctrl-j:print-query')}", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys 'print-my-query', 'C-j'
+    assert_equal %w[print-my-query], fzf_output_lines
+  end
+
+  def test_bind_replace_query
+    tmux.send_keys "seq 1 1000 | #{fzf('--print-query --bind=ctrl-j:replace-query')}", :Enter
+    tmux.send_keys '1'
+    tmux.until { |lines| assert_equal '  272/1000', lines[-2] }
+    tmux.send_keys 'C-k', 'C-j'
+    tmux.until { |lines| assert_equal '  29/1000', lines[-2] }
+    tmux.until { |lines| assert_equal '> 10', lines[-1] }
+  end
+
+  def test_select_all_deselect_all_toggle_all
+    tmux.send_keys "seq 100 | #{fzf('--bind ctrl-a:select-all,ctrl-d:deselect-all,ctrl-t:toggle-all --multi')}", :Enter
+    tmux.until { |lines| assert_equal '  100/100 (0)', lines[-2] }
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until { |lines| assert_equal '  100/100 (3)', lines[-2] }
+    tmux.send_keys 'C-t'
+    tmux.until { |lines| assert_equal '  100/100 (97)', lines[-2] }
+    tmux.send_keys 'C-a'
+    tmux.until { |lines| assert_equal '  100/100 (100)', lines[-2] }
+    tmux.send_keys :Tab, :Tab
+    tmux.until { |lines| assert_equal '  100/100 (98)', lines[-2] }
+    tmux.send_keys '100'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys 'C-d'
+    tmux.until { |lines| assert_equal '  1/100 (97)', lines[-2] }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| assert_equal 100, lines.match_count }
+    tmux.send_keys 'C-d'
+    tmux.until { |lines| assert_equal '  100/100 (0)', lines[-2] }
+    tmux.send_keys :BTab, :BTab
+    tmux.until { |lines| assert_equal '  100/100 (2)', lines[-2] }
+    tmux.send_keys 0
+    tmux.until { |lines| assert_equal '  10/100 (2)', lines[-2] }
+    tmux.send_keys 'C-a'
+    tmux.until { |lines| assert_equal '  10/100 (12)', lines[-2] }
+    tmux.send_keys :Enter
+    assert_equal %w[1 2 10 20 30 40 50 60 70 80 90 100],
+                 fzf_output_lines
+  end
+
+  def test_history
+    history_file = '/tmp/fzf-test-history'
+
+    # History with limited number of entries
+    FileUtils.rm_f(history_file)
+    opts = "--history=#{history_file} --history-size=4"
+    input = %w[00 11 22 33 44]
+    input.each do |keys|
+      tmux.prepare
+      tmux.send_keys "seq 100 | #{FZF} #{opts}", :Enter
+      tmux.until { |lines| assert_equal '  100/100', lines[-2] }
+      tmux.send_keys keys
+      tmux.until { |lines| assert_equal '  1/100', lines[-2] }
+      tmux.send_keys :Enter
+    end
+    wait do
+      assert_path_exists history_file
+      assert_equal input[1..], File.readlines(history_file, chomp: true)
+    end
+
+    # Update history entries (not changed on disk)
+    tmux.send_keys "seq 100 | #{FZF} #{opts}", :Enter
+    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
+    tmux.send_keys 'C-p'
+    tmux.until { |lines| assert_equal '> 44', lines[-1] }
+    tmux.send_keys 'C-p'
+    tmux.until { |lines| assert_equal '> 33', lines[-1] }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal '> 3', lines[-1] }
+    tmux.send_keys 1
+    tmux.until { |lines| assert_equal '> 31', lines[-1] }
+    tmux.send_keys 'C-p'
+    tmux.until { |lines| assert_equal '> 22', lines[-1] }
+    tmux.send_keys 'C-n'
+    tmux.until { |lines| assert_equal '> 31', lines[-1] }
+    tmux.send_keys 0
+    tmux.until { |lines| assert_equal '> 310', lines[-1] }
+    tmux.send_keys :Enter
+    wait do
+      assert_path_exists history_file
+      assert_equal %w[22 33 44 310], File.readlines(history_file, chomp: true)
+    end
+
+    # Respect --bind option
+    tmux.send_keys "seq 100 | #{FZF} #{opts} --bind ctrl-p:next-history,ctrl-n:previous-history", :Enter
+    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
+    tmux.send_keys 'C-n', 'C-n', 'C-n', 'C-n', 'C-p'
+    tmux.until { |lines| assert_equal '> 33', lines[-1] }
+    tmux.send_keys :Enter
+  ensure
+    FileUtils.rm_f(history_file)
+  end
+
+  def test_cycle
+    tmux.send_keys "seq 8 | #{FZF} --cycle", :Enter
+    tmux.until { |lines| assert_equal '  8/8', lines[-2] }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_equal '> 8', lines[-10] }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_equal '> 7', lines[-9] }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal '> 8', lines[-10] }
+    tmux.send_keys :PgUp
+    tmux.until { |lines| assert_equal '> 8', lines[-10] }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal '> 1', lines[-3] }
+    tmux.send_keys :PgDn
+    tmux.until { |lines| assert_equal '> 1', lines[-3] }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_equal '> 8', lines[-10] }
+  end
+
+  def test_header_lines
+    tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5')}", :Enter
+    2.times do
+      tmux.until do |lines|
+        assert_equal '  18/90', lines[-2]
+        assert_equal '  1', lines[-3]
+        assert_equal '  2', lines[-4]
+        assert_equal '> 50', lines[-13]
+      end
+      tmux.send_keys :Down
+    end
+    tmux.send_keys :Enter
+    assert_equal '50', fzf_output
+  end
+
+  def test_header_lines_reverse
+    tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5 --reverse')}", :Enter
+    2.times do
+      tmux.until do |lines|
+        assert_equal '  18/90', lines[1]
+        assert_equal '  1', lines[2]
+        assert_equal '  2', lines[3]
+        assert_equal '> 50', lines[12]
+      end
+      tmux.send_keys :Up
+    end
+    tmux.send_keys :Enter
+    assert_equal '50', fzf_output
+  end
+
+  def test_header_lines_reverse_list
+    tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5 --layout=reverse-list')}", :Enter
+    2.times do
+      tmux.until do |lines|
+        assert_equal '> 50', lines[0]
+        assert_equal '  2', lines[-4]
+        assert_equal '  1', lines[-3]
+        assert_equal '  18/90', lines[-2]
+      end
+      tmux.send_keys :Up
+    end
+    tmux.send_keys :Enter
+    assert_equal '50', fzf_output
+  end
+
+  def test_header_lines_overflow
+    tmux.send_keys "seq 100 | #{fzf('--header-lines=200')}", :Enter
+    tmux.until do |lines|
+      assert_equal '  0/0', lines[-2]
+      assert_equal '  1', lines[-3]
+    end
+    tmux.send_keys :Enter
+    assert_equal '', fzf_output
+  end
+
+  def test_header_lines_with_nth
+    tmux.send_keys "seq 100 | #{fzf('--header-lines 5 --with-nth 1,1,1,1,1')}", :Enter
+    tmux.until do |lines|
+      assert_equal '  95/95', lines[-2]
+      assert_equal '  11111', lines[-3]
+      assert_equal '  55555', lines[-7]
+      assert_equal '> 66666', lines[-8]
+    end
+    tmux.send_keys :Enter
+    assert_equal '6', fzf_output
+  end
+
+  def test_header
+    tmux.send_keys %[seq 100 | #{FZF} --header "$(head -5 #{FILE})"], :Enter
+    header = File.readlines(FILE, chomp: true).take(5)
+    tmux.until do |lines|
+      assert_equal '  100/100', lines[-2]
+      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7..-3]
+      assert_equal '> 1', lines[-8]
+    end
+  end
+
+  def test_header_reverse
+    tmux.send_keys %[seq 100 | #{FZF} --header "$(head -5 #{FILE})" --reverse], :Enter
+    header = File.readlines(FILE, chomp: true).take(5)
+    tmux.until do |lines|
+      assert_equal '  100/100', lines[1]
+      assert_equal header.map { |line| "  #{line}".rstrip }, lines[2..6]
+      assert_equal '> 1', lines[7]
+    end
+  end
+
+  def test_header_reverse_list
+    tmux.send_keys %[seq 100 | #{FZF} --header "$(head -5 #{FILE})" --layout=reverse-list], :Enter
+    header = File.readlines(FILE, chomp: true).take(5)
+    tmux.until do |lines|
+      assert_equal '  100/100', lines[-2]
+      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7..-3]
+      assert_equal '> 1', lines[0]
+    end
+  end
+
+  def test_header_and_header_lines
+    tmux.send_keys %[seq 100 | #{FZF} --header-lines 10 --header "$(head -5 #{FILE})"], :Enter
+    header = File.readlines(FILE, chomp: true).take(5)
+    tmux.until do |lines|
+      assert_equal '  90/90', lines[-2]
+      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7...-2]
+      assert_equal ('  1'..'  10').to_a.reverse, lines[-17...-7]
+    end
+  end
+
+  def test_header_and_header_lines_reverse
+    tmux.send_keys %[seq 100 | #{FZF} --reverse --header-lines 10 --header "$(head -5 #{FILE})"], :Enter
+    header = File.readlines(FILE, chomp: true).take(5)
+    tmux.until do |lines|
+      assert_equal '  90/90', lines[1]
+      assert_equal header.map { |line| "  #{line}".rstrip }, lines[2...7]
+      assert_equal ('  1'..'  10').to_a, lines[7...17]
+    end
+  end
+
+  def test_header_and_header_lines_reverse_list
+    tmux.send_keys %[seq 100 | #{FZF} --layout=reverse-list --header-lines 10 --header "$(head -5 #{FILE})"], :Enter
+    header = File.readlines(FILE, chomp: true).take(5)
+    tmux.until do |lines|
+      assert_equal '  90/90', lines[-2]
+      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7...-2]
+      assert_equal ('  1'..'  10').to_a.reverse, lines[-17...-7]
+    end
+  end
+
+  def test_cancel
+    tmux.send_keys "seq 10 | #{FZF} --bind 2:cancel", :Enter
+    tmux.until { |lines| assert_equal '  10/10', lines[-2] }
+    tmux.send_keys '123'
+    tmux.until do |lines|
+      assert_equal '> 3', lines[-1]
+      assert_equal '  1/10', lines[-2]
+    end
+    tmux.send_keys 'C-y', 'C-y'
+    tmux.until { |lines| assert_equal '> 311', lines[-1] }
+    tmux.send_keys 2
+    tmux.until { |lines| assert_equal '>', lines[-1] }
+    tmux.send_keys 2
+    tmux.prepare
+  end
+
+  def test_margin
+    tmux.send_keys "yes | head -1000 | #{FZF} --margin 5,3", :Enter
+    tmux.until do |lines|
+      assert_equal '', lines[4]
+      assert_equal '     y', lines[5]
+    end
+    tmux.send_keys :Enter
+  end
+
+  def test_margin_reverse
+    tmux.send_keys "seq 1000 | #{FZF} --margin 7,5 --reverse", :Enter
+    tmux.until { |lines| assert_equal '       1000/1000', lines[1 + 7] }
+    tmux.send_keys :Enter
+  end
+
+  def test_margin_reverse_list
+    tmux.send_keys "yes | head -1000 | #{FZF} --margin 5,3 --layout=reverse-list", :Enter
+    tmux.until do |lines|
+      assert_equal '', lines[4]
+      assert_equal '   > y', lines[5]
+    end
+    tmux.send_keys :Enter
+  end
+
+  def test_tabstop
+    writelines(%W[f\too\tba\tr\tbaz\tbarfooq\tux])
+    {
+      1 => '> f oo ba r baz barfooq ux',
+      2 => '> f oo  ba  r baz barfooq ux',
+      3 => '> f  oo ba r  baz   barfooq  ux',
+      4 => '> f   oo  ba  r   baz barfooq ux',
+      5 => '> f    oo   ba   r    baz  barfooq   ux',
+      6 => '> f     oo    ba    r     baz   barfooq     ux',
+      7 => '> f      oo     ba     r      baz    barfooq       ux',
+      8 => '> f       oo      ba      r       baz     barfooq ux',
+      9 => '> f        oo       ba       r        baz      barfooq  ux'
+    }.each do |ts, exp|
+      tmux.prepare
+      tmux.send_keys %(cat #{tempname} | fzf --tabstop=#{ts}), :Enter
+      tmux.until(true) do |lines|
+        assert_equal exp, lines[-3]
+      end
+      tmux.send_keys :Enter
+    end
+  end
+
+  def test_exit_0_exit_code
+    `echo foo | #{FZF} -q bar -0`
+    assert_equal 1, $CHILD_STATUS.exitstatus
+  end
+
+  def test_invalid_option
+    lines = `#{FZF} --foobar 2>&1`
+    assert_equal 2, $CHILD_STATUS.exitstatus
+    assert_includes lines, 'unknown option: --foobar'
+  end
+
+  def test_exitstatus_empty
+    { '99' => '0', '999' => '1' }.each do |query, status|
+      tmux.send_keys "seq 100 | #{FZF} -q #{query}; echo --$?--", :Enter
+      tmux.until { |lines| assert_match %r{ [10]/100}, lines[-2] }
+      tmux.send_keys :Enter
+      tmux.until { |lines| assert_equal "--#{status}--", lines.last }
+    end
+  end
+
+  def test_hscroll_off
+    writelines([('=' * 10_000) + '0123456789'])
+    [0, 3, 6].each do |off|
+      tmux.prepare
+      tmux.send_keys "#{FZF} --hscroll-off=#{off} -q 0 --bind space:toggle-hscroll < #{tempname}", :Enter
+      tmux.until { |lines| assert lines[-3]&.end_with?((0..off).to_a.join + '··') }
+      tmux.send_keys '9'
+      tmux.until { |lines| assert lines[-3]&.end_with?('789') }
+      tmux.send_keys :Space
+      tmux.until { |lines| assert lines[-3]&.end_with?('=··') }
+      tmux.send_keys :Space
+      tmux.until { |lines| assert lines[-3]&.end_with?('789') }
+      tmux.send_keys :Enter
+    end
+  end
+
+  def test_partial_caching
+    tmux.send_keys 'seq 1000 | fzf -e', :Enter
+    tmux.until { |lines| assert_equal '  1000/1000', lines[-2] }
+    tmux.send_keys 11
+    tmux.until { |lines| assert_equal '  19/1000', lines[-2] }
+    tmux.send_keys 'C-a', "'"
+    tmux.until { |lines| assert_equal '  28/1000', lines[-2] }
+    tmux.send_keys :Enter
+  end
+
+  def test_jump
+    tmux.send_keys "seq 1000 | #{fzf("--multi --jump-labels 12345 --bind 'ctrl-j:jump'")}", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys 'C-j'
+    tmux.until { |lines| assert_equal '5 5', lines[-7] }
+    tmux.until { |lines| assert_equal '  6', lines[-8] }
+    tmux.send_keys '5'
+    tmux.until { |lines| assert_equal '> 5', lines[-7] }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal ' >5', lines[-7] }
+    tmux.send_keys 'C-j'
+    tmux.until { |lines| assert_equal '5>5', lines[-7] }
+    tmux.send_keys '2'
+    tmux.until { |lines| assert_equal '> 2', lines[-4] }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal ' >2', lines[-4] }
+    tmux.send_keys 'C-j'
+    tmux.until { |lines| assert_equal '5>5', lines[-7] }
+
+    # Press any key other than jump labels to cancel jump
+    tmux.send_keys '6'
+    tmux.until { |lines| assert_equal '> 1', lines[-3] }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal '>>1', lines[-3] }
+    tmux.send_keys :Enter
+    assert_equal %w[5 2 1], fzf_output_lines
+  end
+
+  def test_jump_accept
+    tmux.send_keys "seq 1000 | #{fzf("--multi --jump-labels 12345 --bind 'ctrl-j:jump-accept'")}", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys 'C-j'
+    tmux.until { |lines| assert_equal '5 5', lines[-7] }
+    tmux.send_keys '3'
+    assert_equal '3', fzf_output
+  end
+
+  def test_jump_events
+    tmux.send_keys "seq 1000 | #{FZF} --multi --jump-labels 12345 --bind 'ctrl-j:jump,jump:preview(echo jumped to {}),jump-cancel:preview(echo jump cancelled at {})'", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
+    tmux.send_keys 'C-j'
+    tmux.until { |lines| assert_includes lines[-7], '5 5' }
+    tmux.send_keys '3'
+    tmux.until { |lines| assert(lines.any? { it.include?('jumped to 3') }) }
+    tmux.send_keys 'C-j'
+    tmux.until { |lines| assert_includes lines[-7], '5 5' }
+    tmux.send_keys 'C-c'
+    tmux.until { |lines| assert(lines.any? { it.include?('jump cancelled at 3') }) }
+  end
+
+  def test_pointer
+    tmux.send_keys "seq 10 | #{fzf("--pointer '>>'")}", :Enter
+    # Assert that specified pointer is displayed
+    tmux.until { |lines| assert_equal '>> 1', lines[-3] }
+  end
+
+  def test_pointer_with_jump
+    tmux.send_keys "seq 10 | #{FZF} --multi --jump-labels 12345 --bind 'ctrl-j:jump' --pointer '>>'", :Enter
+    tmux.until { |lines| assert_equal '  10/10 (0)', lines[-2] }
+    tmux.send_keys 'C-j'
+    # Correctly padded jump label should appear
+    tmux.until { |lines| assert_equal '5  5', lines[-7] }
+    tmux.until { |lines| assert_equal '   6', lines[-8] }
+    tmux.send_keys '5'
+    # Assert that specified pointer is displayed
+    tmux.until { |lines| assert_equal '>> 5', lines[-7] }
+  end
+
+  def test_marker
+    tmux.send_keys "seq 10 | #{FZF} --multi --marker '>>'", :Enter
+    tmux.until { |lines| assert_equal '  10/10 (0)', lines[-2] }
+    tmux.send_keys :BTab
+    # Assert that specified marker is displayed
+    tmux.until { |lines| assert_equal ' >>1', lines[-3] }
+  end
+
+  def test_no_clear
+    tmux.send_keys "seq 10 | #{fzf('--no-clear --inline-info --height 5')}", :Enter
+    prompt = '>   < 10/10'
+    tmux.until { |lines| assert_equal prompt, lines[-1] }
+    tmux.send_keys :Enter
+    assert_equal %w[1], fzf_output_lines
+    tmux.until { |lines| assert_equal prompt, lines[-1] }
+  end
+
+  def test_info_hidden
+    tmux.send_keys 'seq 10 | fzf --info=hidden --no-separator', :Enter
+    tmux.until { |lines| assert_equal '> 1', lines[-2] }
+  end
+
+  def test_info_inline_separator
+    tmux.send_keys 'seq 10 | fzf --info=inline:___ --no-separator', :Enter
+    tmux.until { |lines| assert_equal '>  ___10/10', lines[-1] }
+  end
+
+  def test_change_first_last
+    tmux.send_keys %(seq 1000 | #{FZF} --bind change:first,alt-Z:last), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal '> 2', lines[-4] }
+    tmux.send_keys 1
+    tmux.until { |lines| assert_equal '> 1', lines[-3] }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal '> 10', lines[-4] }
+    tmux.send_keys 1
+    tmux.until { |lines| assert_equal '> 11', lines[-3] }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| assert_equal '> 1', lines[-3] }
+    tmux.send_keys :Escape, 'Z'
+    tmux.until { |lines| assert_equal '> 1000', lines[0] }
+    tmux.send_keys :Enter
+  end
+
+  def test_pos
+    tmux.send_keys %(seq 1000 | #{FZF} --bind 'a:pos(3),b:pos(-3),c:pos(1),d:pos(-1),e:pos(0)' --preview 'echo {}/{}'), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys :a
+    tmux.until { |lines| assert_includes lines[1], ' 3/3' }
+    tmux.send_keys :b
+    tmux.until { |lines| assert_includes lines[1], ' 998/998' }
+    tmux.send_keys :c
+    tmux.until { |lines| assert_includes lines[1], ' 1/1' }
+    tmux.send_keys :d
+    tmux.until { |lines| assert_includes lines[1], ' 1000/1000' }
+    tmux.send_keys :e
+    tmux.until { |lines| assert_includes lines[1], ' 1/1' }
+  end
+
+  def test_put
+    tmux.send_keys %(seq 1000 | #{FZF} --bind 'a:put+put,b:put+put(ravo)' --preview 'echo {q}/{q}'), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys :a
+    tmux.until { |lines| assert_includes lines[1], ' aa/aa' }
+    tmux.send_keys :b
+    tmux.until { |lines| assert_includes lines[1], ' aabravo/aabravo' }
+  end
+
+  def test_accept_non_empty
+    tmux.send_keys %(seq 1000 | #{fzf('--print-query --bind enter:accept-non-empty')}), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys 'foo'
+    tmux.until { |lines| assert_equal '  0/1000', lines[-2] }
+    # fzf doesn't exit since there's no selection
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal '  0/1000', lines[-2] }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| assert_equal '  1000/1000', lines[-2] }
+    tmux.send_keys '999'
+    tmux.until { |lines| assert_equal '  1/1000', lines[-2] }
+    tmux.send_keys :Enter
+    assert_equal %w[999 999], fzf_output_lines
+  end
+
+  def test_accept_non_empty_with_multi_selection
+    tmux.send_keys %(seq 1000 | #{fzf('-m --print-query --bind enter:accept-non-empty')}), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal '  1000/1000 (1)', lines[-2] }
+    tmux.send_keys 'foo'
+    tmux.until { |lines| assert_equal '  0/1000 (1)', lines[-2] }
+    # fzf will exit in this case even though there's no match for the current query
+    tmux.send_keys :Enter
+    assert_equal %w[foo 1], fzf_output_lines
+  end
+
+  def test_accept_non_empty_with_empty_list
+    tmux.send_keys %(: | #{fzf('-q foo --print-query --bind enter:accept-non-empty')}), :Enter
+    tmux.until { |lines| assert_equal '  0/0', lines[-2] }
+    tmux.send_keys :Enter
+    # fzf will exit anyway since input list is empty
+    assert_equal %w[foo], fzf_output_lines
+  end
+
+  def test_accept_or_print_query_without_match
+    tmux.send_keys %(seq 1000 | #{fzf('--bind enter:accept-or-print-query')}), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys 99_999
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.send_keys :Enter
+    assert_equal %w[99999], fzf_output_lines
+  end
+
+  def test_accept_or_print_query_with_match
+    tmux.send_keys %(seq 1000 | #{fzf('--bind enter:accept-or-print-query')}), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys '^99$'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Enter
+    assert_equal %w[99], fzf_output_lines
+  end
+
+  def test_accept_or_print_query_with_multi_selection
+    tmux.send_keys %(seq 1000 | #{fzf('--bind enter:accept-or-print-query --multi')}), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until { |lines| assert_equal 3, lines.select_count }
+    tmux.send_keys 99_999
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.send_keys :Enter
+    assert_equal %w[1 2 3], fzf_output_lines
+  end
+
+  def test_inverse_only_search_should_not_sort_the_result
+    # Filter
+    assert_equal %w[aaaaa b ccc],
+                 `printf '%s\n' aaaaa b ccc BAD | #{FZF} -f '!bad'`.lines(chomp: true)
+
+    # Interactive
+    tmux.send_keys %(printf '%s\n' aaaaa b ccc BAD | #{FZF} -q '!bad'), :Enter
+    tmux.until do |lines|
+      assert_equal 4, lines.item_count
+      assert_equal 3, lines.match_count
+    end
+    tmux.until { |lines| assert_equal '> aaaaa', lines[-3] }
+    tmux.until { |lines| assert_equal '  b', lines[-4] }
+    tmux.until { |lines| assert_equal '  ccc', lines[-5] }
+  end
+
+  def test_disabled
+    tmux.send_keys %(seq 1000 | #{FZF} --query 333 --disabled --bind a:enable-search,b:disable-search,c:toggle-search --preview 'echo {} {q}'), :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' 1 333 ' }
+    tmux.send_keys 'foo'
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' 1 333foo ' }
+
+    # Already disabled, no change
+    tmux.send_keys 'b'
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+
+    # Enable search
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.send_keys :BSpace, :BSpace, :BSpace
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' 333 333 ' }
+
+    # Toggle search -> disabled again, but retains the previous result
+    tmux.send_keys 'c'
+    tmux.send_keys 'foo'
+    tmux.until { |lines| assert_includes lines[1], ' 333 333foo ' }
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+
+    # Enabled, no match
+    tmux.send_keys 'c'
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' 333foo ' }
+  end
+
+  def test_clear_query
+    tmux.send_keys %(: | #{FZF} --query foo --bind space:clear-query), :Enter
+    tmux.until { |lines| assert_equal 0, lines.item_count }
+    tmux.until { |lines| assert_equal '> foo', lines.last }
+    tmux.send_keys 'C-a', 'bar'
+    tmux.until { |lines| assert_equal '> barfoo', lines.last }
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_equal '>', lines.last }
+  end
+
+  def test_change_query
+    tmux.send_keys %(: | #{FZF} --query foo --bind space:change-query:foobar), :Enter
+    tmux.until { |lines| assert_equal 0, lines.item_count }
+    tmux.until { |lines| assert_equal '> foo', lines.last }
+    tmux.send_keys :Space, 'baz'
+    tmux.until { |lines| assert_equal '> foobarbaz', lines.last }
+  end
+
+  def test_transform_query
+    tmux.send_keys %{#{FZF} --bind 'ctrl-r:transform-query(rev <<< {q}),ctrl-u:transform-query: tr "[:lower:]" "[:upper:]" <<< {q}' --query bar}, :Enter
+    tmux.until { |lines| assert_equal '> bar', lines[-1] }
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| assert_equal '> rab', lines[-1] }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| assert_equal '> RAB', lines[-1] }
+  end
+
+  def test_transform_prompt
+    tmux.send_keys %{#{FZF} --bind 'ctrl-r:transform-query(rev <<< {q}),ctrl-u:transform-query: tr "[:lower:]" "[:upper:]" <<< {q}' --query bar}, :Enter
+    tmux.until { |lines| assert_equal '> bar', lines[-1] }
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| assert_equal '> rab', lines[-1] }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| assert_equal '> RAB', lines[-1] }
+  end
+
+  def test_transform
+    tmux.send_keys %{#{FZF} --bind 'focus:transform:echo "change-prompt({fzf:action})"'}, :Enter
+    tmux.until { |lines| assert_equal 'start', lines[-1] }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal 'up', lines[-1] }
+  end
+
+  def test_clear_selection
+    tmux.send_keys %(seq 100 | #{FZF} --multi --bind space:clear-selection), :Enter
+    tmux.until { |lines| assert_equal 100, lines.match_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal '  100/100 (1)', lines[-2] }
+    tmux.send_keys 'foo'
+    tmux.until { |lines| assert_equal '  0/100 (1)', lines[-2] }
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_equal '  0/100 (0)', lines[-2] }
+  end
+
+  def test_backward_delete_char_eof
+    tmux.send_keys "seq 1000 | #{FZF} --bind 'bs:backward-delete-char/eof'", :Enter
+    tmux.until { |lines| assert_equal '  1000/1000', lines[-2] }
+    tmux.send_keys '11'
+    tmux.until { |lines| assert_equal '> 11', lines[-1] }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal '> 1', lines[-1] }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal '>', lines[-1] }
+    tmux.send_keys :BSpace
+    tmux.prepare
+  end
+
+  def test_strip_xterm_osc_sequence
+    %W[\x07 \x1b\\].each do |esc|
+      writelines([%(printf $1"\e]4;3;rgb:aa/bb/cc#{esc} "$2)])
+      File.chmod(0o755, tempname)
+      tmux.prepare
+      tmux.send_keys \
+        %(echo foo bar | #{FZF} --preview '#{tempname} {2} {1}'), :Enter
+
+      tmux.until { |lines| assert lines.any_include?('bar foo') }
+      tmux.send_keys :Enter
+    end
+  end
+
+  def test_keep_right
+    tmux.send_keys "seq 10000 | #{FZF} --read0 --keep-right --no-multi-line --bind space:toggle-multi-line", :Enter
+    tmux.until { |lines| assert lines.any_include?('9999␊10000') }
+    tmux.send_keys :Space
+    tmux.until { |lines| assert lines.any_include?('> 1') }
+    tmux.send_keys :Space
+    tmux.until { |lines| assert lines.any_include?('9999␊10000') }
+  end
+
+  def test_backward_eof
+    tmux.send_keys "echo foo | #{FZF} --bind 'backward-eof:reload(seq 100)'", :Enter
+    tmux.until { |lines| lines.item_count == 1 && lines.match_count == 1 }
+    tmux.send_keys 'x'
+    tmux.until { |lines| lines.item_count == 1 && lines.match_count == 0 }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| lines.item_count == 1 && lines.match_count == 1 }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| lines.item_count == 100 && lines.match_count == 100 }
+  end
+
+  def test_change_prompt
+    tmux.send_keys "#{FZF} --bind 'a:change-prompt(a> ),b:change-prompt:b> ' --query foo", :Enter
+    tmux.until { |lines| assert_equal '> foo', lines[-1] }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_equal 'a> foo', lines[-1] }
+    tmux.send_keys 'b'
+    tmux.until { |lines| assert_equal 'b> foo', lines[-1] }
+  end
+
+  def test_select_deselect
+    tmux.send_keys "seq 3 | #{FZF} --multi --bind up:deselect+up,down:select+down", :Enter
+    tmux.until { |lines| assert_equal 3, lines.match_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal 1, lines.select_count }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal 0, lines.select_count }
+    tmux.send_keys :Down, :Down
+    tmux.until { |lines| assert_equal 2, lines.select_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal 1, lines.select_count }
+    tmux.send_keys :Down, :Down
+    tmux.until { |lines| assert_equal 2, lines.select_count }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal 1, lines.select_count }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_equal 1, lines.select_count }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_equal 2, lines.select_count }
+  end
+
+  def test_unbind_rebind
+    tmux.send_keys "seq 100 | #{FZF} --bind 'c:clear-query,d:unbind(c,d),e:rebind(c,d)'", :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys 'ab'
+    tmux.until { |lines| assert_equal '> ab', lines[-1] }
+    tmux.send_keys 'c'
+    tmux.until { |lines| assert_equal '>', lines[-1] }
+    tmux.send_keys 'dabcd'
+    tmux.until { |lines| assert_equal '> abcd', lines[-1] }
+    tmux.send_keys 'ecabddc'
+    tmux.until { |lines| assert_equal '> abdc', lines[-1] }
+  end
+
+  def test_scroll_off
+    tmux.send_keys "seq 1000 | #{FZF} --scroll-off=3 --bind l:last", :Enter
+    tmux.until { |lines| assert_equal 1000, lines.item_count }
+    height = tmux.until { |lines| lines }.first.to_i
+    tmux.send_keys :PgUp
+    tmux.until do |lines|
+      assert_equal height + 3, lines.first.to_i
+      assert_equal "> #{height}", lines[3].strip
+    end
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal "> #{height + 1}", lines[3].strip }
+    tmux.send_keys 'l'
+    tmux.until { |lines| assert_equal '> 1000', lines.first.strip }
+    tmux.send_keys :PgDn
+    tmux.until { |lines| assert_equal "> #{1000 - height + 1}", lines.reverse[5].strip }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_equal "> #{1000 - height}", lines.reverse[5].strip }
+  end
+
+  def test_scroll_off_large
+    tmux.send_keys "seq 1000 | #{FZF} --scroll-off=9999", :Enter
+    tmux.until { |lines| assert_equal 1000, lines.item_count }
+    height = tmux.until { |lines| lines }.first.to_i
+    tmux.send_keys :PgUp
+    tmux.until { |lines| assert_equal "> #{height}", lines[height / 2].strip }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal "> #{height + 1}", lines[height / 2].strip }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal "> #{height + 2}", lines[height / 2].strip }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_equal "> #{height + 1}", lines[height / 2].strip }
+  end
+
+  def test_ellipsis
+    tmux.send_keys 'seq 1000 | tr "\n" , | fzf --ellipsis=SNIPSNIP -e -q500', :Enter
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.until { |lines| assert_match(/^> SNIPSNIP.*SNIPSNIP$/, lines[-3]) }
+  end
+
+  def test_start_event
+    tmux.send_keys 'seq 100 | fzf --multi --sync --preview-window hidden:border-none --bind "start:select-all+last+preview(echo welcome)"', :Enter
+    tmux.until do |lines|
+      assert_match(/>100.*welcome/, lines[0])
+      assert_includes(lines[-2], '100/100 (100)')
+    end
+  end
+
+  def test_focus_event
+    tmux.send_keys 'seq 100 | fzf --bind "focus:transform-prompt(echo [[{}]]),?:unbind(focus)"', :Enter
+    tmux.until { |lines| assert_includes(lines[-1], '[[1]]') }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes(lines[-1], '[[2]]') }
+    tmux.send_keys :X
+    tmux.until { |lines| assert_includes(lines[-1], '[[]]') }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_includes(lines[-1], '[[1]]') }
+    tmux.send_keys :X
+    tmux.until { |lines| assert_includes(lines[-1], '[[]]') }
+    tmux.send_keys '?'
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 100, lines.match_count }
+    tmux.until { |lines| refute_includes(lines[-1], '[[1]]') }
+  end
+
+  def test_result_event
+    tmux.send_keys '(echo 0; seq 10) | fzf --bind "result:pos(2)"', :Enter
+    tmux.until { |lines| assert_equal 11, lines.item_count }
+    tmux.until { |lines| assert_includes lines, '> 1' }
+    tmux.send_keys '9'
+    tmux.until { |lines| assert_includes lines, '> 9' }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_includes lines, '> 1' }
+  end
+
+  def test_labels_center
+    tmux.send_keys 'echo x | fzf --border --border-label foobar --preview : --preview-label barfoo --bind "space:change-border-label(foobarfoo)+change-preview-label(barfoobar),enter:transform-border-label(echo foo{}foo)+transform-preview-label(echo bar{}bar)"', :Enter
+    tmux.until do
+      assert_includes(it[0], '─foobar─')
+      assert_includes(it[1], '─barfoo─')
+    end
+    tmux.send_keys :space
+    tmux.until do
+      assert_includes(it[0], '─foobarfoo─')
+      assert_includes(it[1], '─barfoobar─')
+    end
+    tmux.send_keys :Enter
+    tmux.until do
+      assert_includes(it[0], '─fooxfoo─')
+      assert_includes(it[1], '─barxbar─')
+    end
+  end
+
+  def test_labels_left
+    tmux.send_keys ': | fzf --border rounded --preview-window border-rounded --border-label foobar --border-label-pos 2 --preview : --preview-label barfoo --preview-label-pos 2', :Enter
+    tmux.until do
+      assert_includes(it[0], '╭foobar─')
+      assert_includes(it[1], '╭barfoo─')
+    end
+  end
+
+  def test_labels_right
+    tmux.send_keys ': | fzf --border rounded --preview-window border-rounded --border-label foobar --border-label-pos -2 --preview : --preview-label barfoo --preview-label-pos -2', :Enter
+    tmux.until do
+      assert_includes(it[0], '─foobar╮')
+      assert_includes(it[1], '─barfoo╮')
+    end
+  end
+
+  def test_labels_bottom
+    tmux.send_keys ': | fzf --border rounded --preview-window border-rounded --border-label foobar --border-label-pos 2:bottom --preview : --preview-label barfoo --preview-label-pos -2:bottom', :Enter
+    tmux.until do
+      assert_includes(it[-1], '╰foobar─')
+      assert_includes(it[-2], '─barfoo╯')
+    end
+  end
+
+  def test_labels_variables
+    tmux.send_keys ': | fzf --border --border-label foobar --preview "echo \$FZF_BORDER_LABEL // \$FZF_PREVIEW_LABEL" --preview-label barfoo --bind "space:change-border-label(barbaz)+change-preview-label(bazbar)+refresh-preview,enter:transform-border-label(echo 123)+transform-preview-label(echo 456)+refresh-preview"', :Enter
+    tmux.until do
+      assert_includes(it[0], '─foobar─')
+      assert_includes(it[1], '─barfoo─')
+      assert_includes(it[2], ' foobar // barfoo ')
+    end
+    tmux.send_keys :Space
+    tmux.until do
+      assert_includes(it[0], '─barbaz─')
+      assert_includes(it[1], '─bazbar─')
+      assert_includes(it[2], ' barbaz // bazbar ')
+    end
+    tmux.send_keys :Enter
+    tmux.until do
+      assert_includes(it[0], '─123─')
+      assert_includes(it[1], '─456─')
+      assert_includes(it[2], ' 123 // 456 ')
+    end
+  end
+
+  def test_info_separator_unicode
+    tmux.send_keys 'seq 100 | fzf -q55', :Enter
+    tmux.until { assert_includes(it[-2], '  1/100 ─') }
+  end
+
+  def test_info_separator_no_unicode
+    tmux.send_keys 'seq 100 | fzf -q55 --no-unicode', :Enter
+    tmux.until { assert_includes(it[-2], '  1/100 -') }
+  end
+
+  def test_info_separator_repeat
+    tmux.send_keys 'seq 100 | fzf -q55 --separator _-', :Enter
+    tmux.until { assert_includes(it[-2], '  1/100 _-_-') }
+  end
+
+  def test_info_separator_ansi_colors_and_tabs
+    tmux.send_keys "seq 100 | fzf -q55 --tabstop 4 --separator $'\\x1b[33ma\\tb'", :Enter
+    tmux.until { assert_includes(it[-2], '  1/100 a   ba   ba') }
+  end
+
+  def test_info_no_separator
+    tmux.send_keys 'seq 100 | fzf -q55 --no-separator', :Enter
+    tmux.until { assert_operator(it[-2], :==, '  1/100') }
+  end
+
+  def test_info_right
+    tmux.send_keys "#{FZF} --info=right --separator x --bind 'start:reload:seq 100; sleep 10'", :Enter
+    tmux.until { assert_match(%r{xxx [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏] 100/100}, it[-2]) }
+  end
+
+  def test_info_inline_right
+    tmux.send_keys "#{FZF} --info=inline-right --bind 'start:reload:seq 100; sleep 10'", :Enter
+    tmux.until { assert_match(%r{[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏] 100/100}, it[-1]) }
+  end
+
+  def test_info_inline_right_clearance
+    tmux.send_keys "seq 100000 | #{FZF} --info inline-right", :Enter
+    tmux.until { assert_match(%r{100000/100000}, it[-1]) }
+    tmux.send_keys 'x'
+    tmux.until { assert_match(%r{     0/100000}, it[-1]) }
+  end
+
+  def test_info_command
+    tmux.send_keys(%(seq 10000 | #{FZF} --separator x --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"'), :Enter)
+    tmux.until { assert_match(%r{^  --1/10000/10000-- xx}, it[-2]) }
+    tmux.send_keys :Up
+    tmux.until { assert_match(%r{^  --2/10000/10000-- xx}, it[-2]) }
+  end
+
+  def test_info_command_inline
+    tmux.send_keys(%(seq 10000 | #{FZF} --separator x --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"' --info inline:xx), :Enter)
+    tmux.until { assert_match(%r{^>  xx--1/10000/10000-- xx}, it[-1]) }
+  end
+
+  def test_info_command_right
+    tmux.send_keys(%(seq 10000 | #{FZF} --separator x --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"' --info right), :Enter)
+    tmux.until { assert_match(%r{xx --1/10000/10000-- *$}, it[-2]) }
+  end
+
+  def test_info_command_inline_right
+    tmux.send_keys(%(seq 10000 | #{FZF} --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"' --info inline-right), :Enter)
+    tmux.until { assert_match(%r{   --1/10000/10000-- *$}, it[-1]) }
+  end
+
+  def test_info_command_and_focus
+    tmux.send_keys(%(seq 100 | #{FZF} --separator x --info-command 'echo $FZF_POS' --bind focus:clear-query), :Enter)
+    tmux.until { assert_match(/^  1 xx/, it[-2]) }
+    tmux.send_keys :Up
+    tmux.until { assert_match(/^  2 xx/, it[-2]) }
+  end
+
+  def test_prev_next_selected
+    tmux.send_keys 'seq 10 | fzf --multi --bind ctrl-n:next-selected,ctrl-p:prev-selected', :Enter
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+    tmux.send_keys :BTab, :BTab, :Up, :BTab
+    tmux.until { |lines| assert_equal 3, lines.select_count }
+    tmux.send_keys 'C-n'
+    tmux.until { |lines| assert_includes lines, '>>4' }
+    tmux.send_keys 'C-n'
+    tmux.until { |lines| assert_includes lines, '>>2' }
+    tmux.send_keys 'C-n'
+    tmux.until { |lines| assert_includes lines, '>>1' }
+    tmux.send_keys 'C-n'
+    tmux.until { |lines| assert_includes lines, '>>4' }
+    tmux.send_keys 'C-p'
+    tmux.until { |lines| assert_includes lines, '>>1' }
+    tmux.send_keys 'C-p'
+    tmux.until { |lines| assert_includes lines, '>>2' }
+  end
+
+  def test_track
+    tmux.send_keys "seq 1000 | #{FZF} --query 555 --track --bind t:toggle-track", :Enter
+    tmux.until do |lines|
+      assert_equal 1, lines.match_count
+      assert_includes lines, '> 555'
+    end
+    tmux.send_keys :BSpace
+    index = tmux.until do |lines|
+      assert_equal 28, lines.match_count
+      assert_includes lines, '> 555'
+    end.index('> 555')
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 271, lines.match_count
+      assert_equal '> 555', lines[index]
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 1000, lines.match_count
+      assert_equal '> 555', lines[index]
+    end
+    tmux.send_keys '555'
+    tmux.until do |lines|
+      assert_equal 1, lines.match_count
+      assert_includes lines, '> 555'
+      assert_includes lines[-2], '+T'
+    end
+    tmux.send_keys 't'
+    tmux.until do |lines|
+      refute_includes lines[-2], '+T'
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 28, lines.match_count
+      assert_includes lines, '> 55'
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 271, lines.match_count
+      assert_includes lines, '> 5'
+    end
+    tmux.send_keys 't'
+    tmux.until do |lines|
+      assert_includes lines[-2], '+T'
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 1000, lines.match_count
+      assert_includes lines, '> 5'
+    end
+  end
+
+  def test_track_action
+    tmux.send_keys "seq 1000 | #{FZF} --query 555 --bind t:track", :Enter
+    tmux.until do |lines|
+      assert_equal 1, lines.match_count
+      assert_includes lines, '> 555'
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 28, lines.match_count
+      assert_includes lines, '> 55'
+    end
+    tmux.send_keys :t
+    tmux.until do |lines|
+      assert_includes lines[-2], '+t'
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 271, lines.match_count
+      assert_includes lines, '> 55'
+    end
+
+    # Automatically disabled when the tracking item is no longer visible
+    tmux.send_keys '4'
+    tmux.until do |lines|
+      assert_equal 28, lines.match_count
+      refute_includes lines[-2], '+t'
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 271, lines.match_count
+      assert_includes lines, '> 5'
+    end
+    tmux.send_keys :t
+    tmux.until do |lines|
+      assert_includes lines[-2], '+t'
+    end
+    tmux.send_keys :Up
+    tmux.until do |lines|
+      refute_includes lines[-2], '+t'
+    end
+  end
+
+  def test_one_and_zero
+    tmux.send_keys "seq 10 | #{FZF} --bind 'zero:preview(echo no match),one:preview(echo {} is the only match)'", :Enter
+    tmux.send_keys '1'
+    tmux.until do |lines|
+      assert_equal 2, lines.match_count
+      refute(lines.any? { it.include?('only match') })
+      refute(lines.any? { it.include?('no match') })
+    end
+    tmux.send_keys '0'
+    tmux.until do |lines|
+      assert_equal 1, lines.match_count
+      assert(lines.any? { it.include?('only match') })
+    end
+    tmux.send_keys '0'
+    tmux.until do |lines|
+      assert_equal 0, lines.match_count
+      assert(lines.any? { it.include?('no match') })
+    end
+  end
+
+  def test_height_range_with_exit_0
+    tmux.send_keys "seq 10 | #{FZF} --height ~10% --exit-0", :Enter
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+    tmux.send_keys :c
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+  end
+
+  def test_delete_with_modifiers
+    if ENV['GITHUB_ACTION']
+      # Expected: "[3]"
+      # Actual: "[]3;5~"
+      skip('CTRL-DELETE is not properly handled in GitHub Actions environment')
+    end
+    tmux.send_keys "seq 100 | #{FZF} --bind 'ctrl-delete:up+up,shift-delete:down,focus:transform-prompt:echo [{}]'", :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys 'C-Delete'
+    tmux.until { |lines| assert_equal '[3]', lines[-1] }
+    tmux.send_keys 'S-Delete'
+    tmux.until { |lines| assert_equal '[2]', lines[-1] }
+  end
+
+  def test_fzf_pos
+    tmux.send_keys "seq 100 | #{FZF} --preview 'echo $FZF_POS / $FZF_MATCH_COUNT'", :Enter
+    tmux.until { |lines| assert(lines.any? { |line| line.include?('1 / 100') }) }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert(lines.any? { |line| line.include?('2 / 100') }) }
+    tmux.send_keys '99'
+    tmux.until { |lines| assert(lines.any? { |line| line.include?('1 / 1') }) }
+    tmux.send_keys '99'
+    tmux.until { |lines| assert(lines.any? { |line| line.include?('0 / 0') }) }
+  end
+
+  def test_change_nth
+    input = [
+      *[''] * 1000,
+      'foo bar bar bar bar',
+      'foo foo bar bar bar',
+      'foo foo foo bar bar',
+      'foo foo foo foo bar',
+      *[''] * 1000
+    ]
+    writelines(input)
+    nths = '1,2..4,-1,-3..,..2'
+    tmux.send_keys %(#{FZF} -qfoo -n#{nths} --bind 'space:change-nth(2|3|4|5|),result:transform-prompt:echo "[$FZF_NTH] "' < #{tempname}), :Enter
+
+    tmux.until do |lines|
+      assert lines.any_include?("[#{nths}] foo")
+      assert_equal 4, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert lines.any_include?('[2] foo')
+      assert_equal 3, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert lines.any_include?('[3] foo')
+      assert_equal 2, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert lines.any_include?('[4] foo')
+      assert_equal 1, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert lines.any_include?('[5] foo')
+      assert_equal 0, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert lines.any_include?("[#{nths}] foo")
+      assert_equal 4, lines.match_count
+    end
+  end
+end
diff --git a/test/test_exec.rb b/test/test_exec.rb
new file mode 100644
index 00000000..9232ce9e
--- /dev/null
+++ b/test/test_exec.rb
@@ -0,0 +1,417 @@
+# frozen_string_literal: true
+
+require_relative 'lib/common'
+
+# Process execution: execute, become, reload
+class TestExec < TestInteractive
+  def test_execute
+    output = '/tmp/fzf-test-execute'
+    opts = %[--bind "alt-a:execute(echo /{}/ >> #{output})+change-header(alt-a),alt-b:execute[echo /{}{}/ >> #{output}]+change-header(alt-b),C:execute(echo /{}{}{}/ >> #{output})+change-header(C)"]
+    writelines(%w[foo'bar foo"bar foo$bar])
+    tmux.send_keys "cat #{tempname} | #{FZF} #{opts}", :Enter
+    tmux.until { |lines| assert_equal 3, lines.item_count }
+
+    ready = ->(s) { tmux.until { |lines| assert_includes lines[-3], s } }
+    tmux.send_keys :Escape, :a
+    ready.call('alt-a')
+    tmux.send_keys :Escape, :b
+    ready.call('alt-b')
+
+    tmux.send_keys :Up
+    tmux.send_keys :Escape, :a
+    ready.call('alt-a')
+    tmux.send_keys :Escape, :b
+    ready.call('alt-b')
+
+    tmux.send_keys :Up
+    tmux.send_keys :C
+    ready.call('C')
+
+    tmux.send_keys 'barfoo'
+    tmux.until { |lines| assert_equal '  0/3', lines[-2] }
+
+    tmux.send_keys :Escape, :a
+    ready.call('alt-a')
+    tmux.send_keys :Escape, :b
+    ready.call('alt-b')
+
+    wait do
+      assert_path_exists output
+      assert_equal %w[
+        /foo'bar/ /foo'barfoo'bar/
+        /foo"bar/ /foo"barfoo"bar/
+        /foo$barfoo$barfoo$bar/
+      ], File.readlines(output, chomp: true)
+    end
+  ensure
+    FileUtils.rm_f(output)
+  end
+
+  def test_execute_multi
+    output = '/tmp/fzf-test-execute-multi'
+    opts = %[--multi --bind "alt-a:execute-multi(echo {}/{+} >> #{output})+change-header(alt-a),alt-b:change-header(alt-b)"]
+    writelines(%w[foo'bar foo"bar foo$bar foobar])
+    tmux.send_keys "cat #{tempname} | #{FZF} #{opts}", :Enter
+    ready = ->(s) { tmux.until { |lines| assert_includes lines[-3], s } }
+
+    tmux.until { |lines| assert_equal '  4/4 (0)', lines[-2] }
+    tmux.send_keys :Escape, :a
+    ready.call('alt-a')
+    tmux.send_keys :Escape, :b
+    ready.call('alt-b')
+
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until { |lines| assert_equal '  4/4 (3)', lines[-2] }
+    tmux.send_keys :Escape, :a
+    ready.call('alt-a')
+    tmux.send_keys :Escape, :b
+    ready.call('alt-b')
+
+    tmux.send_keys :Tab, :Tab
+    tmux.until { |lines| assert_equal '  4/4 (3)', lines[-2] }
+    tmux.send_keys :Escape, :a
+    ready.call('alt-a')
+    wait do
+      assert_path_exists output
+      assert_equal [
+        %(foo'bar/foo'bar),
+        %(foo'bar foo"bar foo$bar/foo'bar foo"bar foo$bar),
+        %(foo'bar foo"bar foobar/foo'bar foo"bar foobar)
+      ], File.readlines(output, chomp: true)
+    end
+  ensure
+    FileUtils.rm_f(output)
+  end
+
+  def test_execute_plus_flag
+    output = tempname + '.tmp'
+    FileUtils.rm_f(output)
+    writelines(['foo bar', '123 456'])
+
+    tmux.send_keys "cat #{tempname} | #{FZF} --multi --bind 'x:execute-silent(echo {+}/{}/{+2}/{2} >> #{output})'", :Enter
+
+    tmux.until { |lines| assert_equal '  2/2 (0)', lines[-2] }
+    tmux.send_keys 'xy'
+    tmux.until { |lines| assert_equal '  0/2 (0)', lines[-2] }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal '  2/2 (0)', lines[-2] }
+
+    tmux.send_keys :Up
+    tmux.send_keys :Tab
+    tmux.send_keys 'xy'
+    tmux.until { |lines| assert_equal '  0/2 (1)', lines[-2] }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal '  2/2 (1)', lines[-2] }
+
+    tmux.send_keys :Tab
+    tmux.send_keys 'xy'
+    tmux.until { |lines| assert_equal '  0/2 (2)', lines[-2] }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal '  2/2 (2)', lines[-2] }
+
+    wait do
+      assert_path_exists output
+      assert_equal [
+        %(foo bar/foo bar/bar/bar),
+        %(123 456/foo bar/456/bar),
+        %(123 456 foo bar/foo bar/456 bar/bar)
+      ], File.readlines(output, chomp: true)
+    end
+  rescue StandardError
+    FileUtils.rm_f(output)
+  end
+
+  def test_execute_shell
+    # Custom script to use as $SHELL
+    output = tempname + '.out'
+    FileUtils.rm_f(output)
+    writelines(['#!/usr/bin/env bash', "echo $1 / $2 > #{output}"])
+    system("chmod +x #{tempname}")
+
+    tmux.send_keys "echo foo | SHELL=#{tempname} fzf --bind 'enter:execute:{}bar'", :Enter
+    tmux.until { |lines| assert_equal '  1/1', lines[-2] }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal '  1/1', lines[-2] }
+    wait do
+      assert_path_exists output
+      assert_equal ["-c / 'foo'bar"], File.readlines(output, chomp: true)
+    end
+  ensure
+    FileUtils.rm_f(output)
+  end
+
+  def test_interrupt_execute
+    tmux.send_keys "seq 100 | #{FZF} --bind 'ctrl-l:execute:echo executing {}; sleep 100'", :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys 'C-l'
+    tmux.until { |lines| assert lines.any_include?('executing 1') }
+    tmux.send_keys 'C-c'
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys 99
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+  end
+
+  def test_kill_default_command_on_abort
+    writelines(['#!/usr/bin/env bash',
+                "echo 'Started'",
+                'while :; do sleep 1; done'])
+    system("chmod +x #{tempname}")
+
+    tmux.send_keys FZF.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND=#{tempname}"), :Enter
+    tmux.until { |lines| assert_equal 1, lines.item_count }
+    tmux.send_keys 'C-c'
+    tmux.send_keys 'C-l', 'closed'
+    tmux.until { |lines| assert_includes lines[0], 'closed' }
+    wait { refute system("pgrep -f #{tempname}") }
+  ensure
+    system("pkill -9 -f #{tempname}")
+  end
+
+  def test_kill_default_command_on_accept
+    writelines(['#!/usr/bin/env bash',
+                "echo 'Started'",
+                'while :; do sleep 1; done'])
+    system("chmod +x #{tempname}")
+
+    tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND=#{tempname}"), :Enter
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Enter
+    assert_equal 'Started', fzf_output
+    wait { refute system("pgrep -f #{tempname}") }
+  ensure
+    system("pkill -9 -f #{tempname}")
+  end
+
+  def test_kill_reload_command_on_abort
+    writelines(['#!/usr/bin/env bash',
+                "echo 'Started'",
+                'while :; do sleep 1; done'])
+    system("chmod +x #{tempname}")
+
+    tmux.send_keys "seq 1 3 | #{FZF} --bind 'ctrl-r:reload(#{tempname})'", :Enter
+    tmux.until { |lines| assert_equal 3, lines.item_count }
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| assert_equal 1, lines.item_count }
+    tmux.send_keys 'C-c'
+    tmux.send_keys 'C-l', 'closed'
+    tmux.until { |lines| assert_includes lines[0], 'closed' }
+    wait { refute system("pgrep -f #{tempname}") }
+  ensure
+    system("pkill -9 -f #{tempname}")
+  end
+
+  def test_kill_reload_command_on_accept
+    writelines(['#!/usr/bin/env bash',
+                "echo 'Started'",
+                'while :; do sleep 1; done'])
+    system("chmod +x #{tempname}")
+
+    tmux.send_keys "seq 1 3 | #{fzf("--bind 'ctrl-r:reload(#{tempname})'")}", :Enter
+    tmux.until { |lines| assert_equal 3, lines.item_count }
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| assert_equal 1, lines.item_count }
+    tmux.send_keys :Enter
+    assert_equal 'Started', fzf_output
+    wait { refute system("pgrep -f #{tempname}") }
+  ensure
+    system("pkill -9 -f #{tempname}")
+  end
+
+  def test_reload
+    tmux.send_keys %(seq 1000 | #{FZF} --bind 'change:reload(seq $FZF_QUERY),a:reload(seq 100),b:reload:seq 200' --header-lines 2 --multi 2), :Enter
+    tmux.until { |lines| assert_equal 998, lines.match_count }
+    tmux.send_keys 'a'
+    tmux.until do |lines|
+      assert_equal 98, lines.item_count
+      assert_equal 98, lines.match_count
+    end
+    tmux.send_keys 'b'
+    tmux.until do |lines|
+      assert_equal 198, lines.item_count
+      assert_equal 198, lines.match_count
+    end
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal '  198/198 (1/2)', lines[-2] }
+    tmux.send_keys '555'
+    tmux.until { |lines| assert_equal '  1/553 (0/2)', lines[-2] }
+  end
+
+  def test_reload_even_when_theres_no_match
+    tmux.send_keys %(: | #{FZF} --bind 'space:reload(seq 10)'), :Enter
+    tmux.until { |lines| assert_equal 0, lines.item_count }
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+  end
+
+  def test_reload_should_terminate_standard_input_stream
+    tmux.send_keys %(ruby -e "STDOUT.sync = true; loop { puts 1; sleep 0.1 }" | fzf --bind 'start:reload(seq 100)'), :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+  end
+
+  def test_clear_list_when_header_lines_changed_due_to_reload
+    tmux.send_keys %(seq 10 | #{FZF} --header 0 --header-lines 3 --bind 'space:reload(seq 1)'), :Enter
+    tmux.until { |lines| assert_includes lines, '  9' }
+    tmux.send_keys :Space
+    tmux.until { |lines| refute_includes lines, '  9' }
+  end
+
+  def test_item_index_reset_on_reload
+    tmux.send_keys "seq 10 | #{FZF} --preview 'echo [[{n}]]' --bind 'up:last,down:first,space:reload:seq 100'", :Enter
+    tmux.until { |lines| assert_includes lines[1], '[[0]]' }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines[1], '[[9]]' }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_includes lines[1], '[[0]]' }
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert_equal 100, lines.item_count
+      assert_includes lines[1], '[[0]]'
+    end
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines[1], '[[99]]' }
+  end
+
+  def test_reload_should_update_preview
+    tmux.send_keys "seq 3 | #{FZF} --bind 'ctrl-t:reload:echo 4' --preview 'echo {}' --preview-window 'nohidden'", :Enter
+    tmux.until { |lines| assert_includes lines[1], '1' }
+    tmux.send_keys 'C-t'
+    tmux.until { |lines| assert_includes lines[1], '4' }
+  end
+
+  def test_reload_and_change_preview_should_update_preview
+    tmux.send_keys "seq 3 | #{FZF} --bind 'ctrl-t:reload(echo 4)+change-preview(echo {})'", :Enter
+    tmux.until { |lines| assert_equal 3, lines.item_count }
+    tmux.until { |lines| refute_includes lines[1], '1' }
+    tmux.send_keys 'C-t'
+    tmux.until { |lines| assert_equal 1, lines.item_count }
+    tmux.until { |lines| assert_includes lines[1], '4' }
+  end
+
+  def test_reload_sync
+    tmux.send_keys "seq 100 | #{FZF} --bind 'load:reload-sync(sleep 1; seq 1000)+unbind(load)'", :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys '00'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    # After 1 second
+    tmux.until { |lines| assert_equal 10, lines.match_count }
+  end
+
+  def test_reload_disabled_case1
+    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload(sleep 2; seq 1000)'", :Enter
+    tmux.until do |lines|
+      assert_equal 100, lines.item_count
+      assert_equal 1, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+  end
+
+  def test_reload_disabled_case2
+    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload-sync(sleep 2; seq 1000)'", :Enter
+    tmux.until do |lines|
+      assert_equal 100, lines.item_count
+      assert_equal 1, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+  end
+
+  def test_reload_disabled_case3
+    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload(sleep 2; seq 1000)+backward-delete-char'", :Enter
+    tmux.until do |lines|
+      assert_equal 100, lines.item_count
+      assert_equal 1, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+  end
+
+  def test_reload_disabled_case4
+    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload-sync(sleep 2; seq 1000)+backward-delete-char'", :Enter
+    tmux.until do |lines|
+      assert_equal 100, lines.item_count
+      assert_equal 1, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+  end
+
+  def test_reload_disabled_case5
+    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload(echo xx; sleep 2; seq 1000)'", :Enter
+    tmux.until do |lines|
+      assert_equal 100, lines.item_count
+      assert_equal 1, lines.match_count
+    end
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert_equal 1, lines.item_count
+      assert_equal 1, lines.match_count
+    end
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 1001, lines.match_count }
+  end
+
+  def test_reload_disabled_case6
+    tmux.send_keys "seq 1000 | #{FZF} --disabled --bind 'change:reload:sleep 0.5; seq {q}'", :Enter
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.send_keys '9'
+    tmux.until { |lines| assert_equal 9, lines.match_count }
+    tmux.send_keys '9'
+    tmux.until { |lines| assert_equal 99, lines.match_count }
+
+    # TODO: How do we verify if an intermediate empty list is not shown?
+  end
+
+  def test_reload_and_change
+    tmux.send_keys "(echo foo; echo bar) | #{FZF} --bind 'load:reload-sync(sleep 60)+change-query(bar)'", :Enter
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+  end
+
+  def test_become_tty
+    tmux.send_keys "sleep 0.5 | #{FZF} --bind 'start:reload:ls' --bind 'load:become:tty'", :Enter
+    tmux.until { |lines| assert_includes lines, '/dev/tty' }
+  end
+
+  def test_disabled_preview_update
+    tmux.send_keys "echo bar | #{FZF} --disabled --bind 'change:reload:echo foo' --preview 'echo [{q}-{}]'", :Enter
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.until { |lines| assert(lines.any? { |line| line.include?('[-bar]') }) }
+    tmux.send_keys :x
+    tmux.until { |lines| assert(lines.any? { |line| line.include?('[x-foo]') }) }
+  end
+
+  def test_start_on_reload
+    tmux.send_keys %(echo foo | #{FZF} --header Loading --header-lines 1 --bind 'start:reload:sleep 2; echo bar' --bind 'load:change-header:Loaded' --bind space:change-header:), :Enter
+    tmux.until(timeout: 1) { |lines| assert_includes lines[-3], 'Loading' }
+    tmux.until(timeout: 1) { |lines| refute_includes lines[-4], 'foo' }
+    tmux.until { |lines| assert_includes lines[-3], 'Loaded' }
+    tmux.until { |lines| assert_includes lines[-4], 'bar' }
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_includes lines[-3], 'bar' }
+  end
+
+  def test_become
+    tmux.send_keys "seq 100 | #{FZF} --bind 'enter:become:seq {} | #{FZF}'", :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys 999
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal 99, lines.item_count }
+  end
+end
diff --git a/test/test_filter.rb b/test/test_filter.rb
new file mode 100644
index 00000000..dc66ec00
--- /dev/null
+++ b/test/test_filter.rb
@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require_relative 'lib/common'
+
+# Non-interactive tests
+class TestFilter < TestBase
+  def test_default_extended
+    assert_equal '100', `seq 100 | #{FZF} -f "1 00$"`.chomp
+    assert_equal '', `seq 100 | #{FZF} -f "1 00$" +x`.chomp
+  end
+
+  def test_exact
+    assert_equal 4, `seq 123 | #{FZF} -f 13`.lines.length
+    assert_equal 2, `seq 123 | #{FZF} -f 13 -e`.lines.length
+    assert_equal 4, `seq 123 | #{FZF} -f 13 +e`.lines.length
+  end
+
+  def test_or_operator
+    assert_equal %w[1 5 10], `seq 10 | #{FZF} -f "1 | 5"`.lines(chomp: true)
+    assert_equal %w[1 10 2 3 4 5 6 7 8 9],
+                 `seq 10 | #{FZF} -f '1 | !1'`.lines(chomp: true)
+  end
+
+  def test_smart_case_for_each_term
+    assert_equal 1, `echo Foo bar | #{FZF} -x -f "foo Fbar" | wc -l`.to_i
+  end
+
+  def test_filter_exitstatus
+    # filter / streaming filter
+    ['', '--no-sort'].each do |opts|
+      assert_includes `echo foo | #{FZF} -f foo #{opts}`, 'foo'
+      assert_equal 0, $CHILD_STATUS.exitstatus
+
+      assert_empty `echo foo | #{FZF} -f bar #{opts}`
+      assert_equal 1, $CHILD_STATUS.exitstatus
+    end
+  end
+
+  def test_long_line
+    data = '.' * 256 * 1024
+    File.open(tempname, 'w') do |f|
+      f << data
+    end
+    assert_equal data, `#{FZF} -f . < #{tempname}`.chomp
+  end
+
+  def test_read0
+    lines = `find .`.lines(chomp: true)
+    assert_equal lines.last, `find . | #{FZF} -e -f "^#{lines.last}$"`.chomp
+    assert_equal \
+      lines.last,
+      `find . -print0 | #{FZF} --read0 -e -f "^#{lines.last}$"`.chomp
+  end
+
+  def test_with_nth_basic
+    writelines(['hello world ', 'byebye'])
+    assert_equal \
+      'hello world ',
+      `#{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 < #{tempname}`.chomp
+  end
+
+  def test_with_nth_ansi
+    writelines(["\x1b[33mhello \x1b[34;1mworld\x1b[m ", 'byebye'])
+    assert_equal \
+      'hello world ',
+      `#{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 --ansi < #{tempname}`.chomp
+  end
+
+  def test_with_nth_no_ansi
+    src = "\x1b[33mhello \x1b[34;1mworld\x1b[m "
+    writelines([src, 'byebye'])
+    assert_equal \
+      src,
+      `#{FZF} -fhehe -x -n 2.. --with-nth 2,1,1 --no-ansi < #{tempname}`.chomp
+  end
+
+  def test_escaped_meta_characters
+    input = [
+      'foo^bar',
+      'foo$bar',
+      'foo!bar',
+      "foo'bar",
+      'foo bar',
+      'bar foo'
+    ]
+    writelines(input)
+
+    assert_equal input.length, `#{FZF} -f'foo bar' < #{tempname}`.lines.length
+    assert_equal input.length - 1, `#{FZF} -f'^foo bar$' < #{tempname}`.lines.length
+    assert_equal ['foo bar'], `#{FZF} -f'foo\\ bar' < #{tempname}`.lines(chomp: true)
+    assert_equal ['foo bar'], `#{FZF} -f'^foo\\ bar$' < #{tempname}`.lines(chomp: true)
+    assert_equal input.length - 1, `#{FZF} -f'!^foo\\ bar$' < #{tempname}`.lines.length
+  end
+
+  def test_normalized_match
+    echoes = '(echo a; echo á; echo A; echo Á;)'
+    assert_equal %w[a á A Á], `#{echoes} | #{FZF} -f a`.lines.map(&:chomp)
+    assert_equal %w[á Á], `#{echoes} | #{FZF} -f á`.lines.map(&:chomp)
+    assert_equal %w[A Á], `#{echoes} | #{FZF} -f A`.lines.map(&:chomp)
+    assert_equal %w[Á], `#{echoes} | #{FZF} -f Á`.lines.map(&:chomp)
+  end
+
+  def test_unicode_case
+    writelines(%w[строКА1 СТРОКА2 строка3 Строка4])
+    assert_equal %w[СТРОКА2 Строка4], `#{FZF} -fС < #{tempname}`.lines(chomp: true)
+    assert_equal %w[строКА1 СТРОКА2 строка3 Строка4], `#{FZF} -fс < #{tempname}`.lines(chomp: true)
+  end
+
+  def test_tiebreak
+    input = %w[
+      --foobar--------
+      -----foobar---
+      ----foobar--
+      -------foobar-
+    ]
+    writelines(input)
+
+    assert_equal input, `#{FZF} -ffoobar --tiebreak=index < #{tempname}`.lines(chomp: true)
+
+    by_length = %w[
+      ----foobar--
+      -----foobar---
+      -------foobar-
+      --foobar--------
+    ]
+    assert_equal by_length, `#{FZF} -ffoobar < #{tempname}`.lines(chomp: true)
+    assert_equal by_length, `#{FZF} -ffoobar --tiebreak=length < #{tempname}`.lines(chomp: true)
+
+    by_begin = %w[
+      --foobar--------
+      ----foobar--
+      -----foobar---
+      -------foobar-
+    ]
+    assert_equal by_begin, `#{FZF} -ffoobar --tiebreak=begin < #{tempname}`.lines(chomp: true)
+    assert_equal by_begin, `#{FZF} -f"!z foobar" -x --tiebreak begin < #{tempname}`.lines(chomp: true)
+
+    assert_equal %w[
+      -------foobar-
+      ----foobar--
+      -----foobar---
+      --foobar--------
+    ], `#{FZF} -ffoobar --tiebreak end < #{tempname}`.lines(chomp: true)
+
+    assert_equal input, `#{FZF} -f"!z" -x --tiebreak end < #{tempname}`.lines(chomp: true)
+  end
+
+  def test_tiebreak_index_begin
+    writelines([
+                 'xoxxxxxoxx',
+                 'xoxxxxxox',
+                 'xxoxxxoxx',
+                 'xxxoxoxxx',
+                 'xxxxoxox',
+                 '  xxoxoxxx'
+               ])
+
+    assert_equal [
+      'xxxxoxox',
+      '  xxoxoxxx',
+      'xxxoxoxxx',
+      'xxoxxxoxx',
+      'xoxxxxxox',
+      'xoxxxxxoxx'
+    ], `#{FZF} -foo < #{tempname}`.lines(chomp: true)
+
+    assert_equal [
+      'xxxoxoxxx',
+      'xxxxoxox',
+      '  xxoxoxxx',
+      'xxoxxxoxx',
+      'xoxxxxxoxx',
+      'xoxxxxxox'
+    ], `#{FZF} -foo --tiebreak=index < #{tempname}`.lines(chomp: true)
+
+    # Note that --tiebreak=begin is now based on the first occurrence of the
+    # first character on the pattern
+    assert_equal [
+      '  xxoxoxxx',
+      'xxxoxoxxx',
+      'xxxxoxox',
+      'xxoxxxoxx',
+      'xoxxxxxoxx',
+      'xoxxxxxox'
+    ], `#{FZF} -foo --tiebreak=begin < #{tempname}`.lines(chomp: true)
+
+    assert_equal [
+      '  xxoxoxxx',
+      'xxxoxoxxx',
+      'xxxxoxox',
+      'xxoxxxoxx',
+      'xoxxxxxox',
+      'xoxxxxxoxx'
+    ], `#{FZF} -foo --tiebreak=begin,length < #{tempname}`.lines(chomp: true)
+  end
+
+  def test_tiebreak_begin_algo_v2
+    writelines(['baz foo bar',
+                'foo bar baz'])
+    assert_equal [
+      'foo bar baz',
+      'baz foo bar'
+    ], `#{FZF} -fbar --tiebreak=begin --algo=v2 < #{tempname}`.lines(chomp: true)
+  end
+
+  def test_tiebreak_end
+    writelines(['xoxxxxxxxx',
+                'xxoxxxxxxx',
+                'xxxoxxxxxx',
+                'xxxxoxxxx',
+                'xxxxxoxxx',
+                '  xxxxoxxx'])
+
+    assert_equal [
+      '  xxxxoxxx',
+      'xxxxoxxxx',
+      'xxxxxoxxx',
+      'xoxxxxxxxx',
+      'xxoxxxxxxx',
+      'xxxoxxxxxx'
+    ], `#{FZF} -fo < #{tempname}`.lines(chomp: true)
+
+    assert_equal [
+      'xxxxxoxxx',
+      '  xxxxoxxx',
+      'xxxxoxxxx',
+      'xxxoxxxxxx',
+      'xxoxxxxxxx',
+      'xoxxxxxxxx'
+    ], `#{FZF} -fo --tiebreak=end < #{tempname}`.lines(chomp: true)
+
+    assert_equal [
+      'xxxxxoxxx',
+      '  xxxxoxxx',
+      'xxxxoxxxx',
+      'xxxoxxxxxx',
+      'xxoxxxxxxx',
+      'xoxxxxxxxx'
+    ], `#{FZF} -fo --tiebreak=end,length,begin < #{tempname}`.lines(chomp: true)
+
+    writelines(['/bar/baz', '/foo/bar/baz'])
+    assert_equal [
+      '/foo/bar/baz',
+      '/bar/baz'
+    ], `#{FZF} -fbaz --tiebreak=end < #{tempname}`.lines(chomp: true)
+  end
+
+  def test_tiebreak_length_with_nth
+    input = %w[
+      1:hell
+      123:hello
+      12345:he
+      1234567:h
+    ]
+    writelines(input)
+
+    output = %w[
+      1:hell
+      12345:he
+      123:hello
+      1234567:h
+    ]
+    assert_equal output, `#{FZF} -fh < #{tempname}`.lines(chomp: true)
+
+    # Since 0.16.8, --nth doesn't affect --tiebreak
+    assert_equal output, `#{FZF} -fh -n2 -d: < #{tempname}`.lines(chomp: true)
+  end
+
+  def test_tiebreak_chunk
+    writelines(['1 foobarbaz ba',
+                '2 foobar baz',
+                '3 foo barbaz'])
+
+    assert_equal [
+      '3 foo barbaz',
+      '2 foobar baz',
+      '1 foobarbaz ba'
+    ], `#{FZF} -fo --tiebreak=chunk < #{tempname}`.lines(chomp: true)
+
+    assert_equal [
+      '1 foobarbaz ba',
+      '2 foobar baz',
+      '3 foo barbaz'
+    ], `#{FZF} -fba --tiebreak=chunk < #{tempname}`.lines(chomp: true)
+
+    assert_equal [
+      '3 foo barbaz'
+    ], `#{FZF} -f'!foobar' --tiebreak=chunk < #{tempname}`.lines(chomp: true)
+  end
+
+  def test_boundary_match
+    # Underscore boundaries should be ranked lower
+    {
+      default: [' x '] + %w[/x/ [x] -x- -x_ _x- _x_],
+      path: ['/x/', ' x '] + %w[[x] -x- -x_ _x- _x_],
+      history: ['[x]', '-x-', ' x '] + %w[/x/ -x_ _x- _x_]
+    }.each do |scheme, expected|
+      result = `printf -- 'xxx\n-xx\nxx-\n_x_\n_x-\n-x_\n[x]\n-x-\n x \n/x/\n' | #{FZF} -f"'x'" --scheme=#{scheme}`.lines(chomp: true)
+      assert_equal expected, result
+    end
+  end
+end
diff --git a/test/test_go.rb b/test/test_go.rb
deleted file mode 100755
index 701bddc8..00000000
--- a/test/test_go.rb
+++ /dev/null
@@ -1,4504 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'fileutils'
-require 'English'
-require 'shellwords'
-require 'erb'
-require 'tempfile'
-require 'net/http'
-require 'json'
-
-TEMPLATE = DATA.read
-UNSETS = %w[
-  FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS
-  FZF_TMUX FZF_TMUX_OPTS
-  FZF_CTRL_T_COMMAND FZF_CTRL_T_OPTS
-  FZF_ALT_C_COMMAND
-  FZF_ALT_C_OPTS FZF_CTRL_R_OPTS
-  FZF_API_KEY
-].freeze
-DEFAULT_TIMEOUT = 10
-
-FILE = File.expand_path(__FILE__)
-BASE = File.expand_path('..', __dir__)
-Dir.chdir(BASE)
-FZF = "FZF_DEFAULT_OPTS=\"--no-scrollbar --pointer \\> --marker \\>\" FZF_DEFAULT_COMMAND= #{BASE}/bin/fzf"
-
-def wait(timeout = DEFAULT_TIMEOUT)
-  since = Time.now
-  begin
-    yield or raise Minitest::Assertion, 'Assertion failure'
-  rescue Minitest::Assertion
-    raise if Time.now - since > timeout
-
-    sleep(0.05)
-    retry
-  end
-end
-
-class Shell
-  class << self
-    def bash
-      @bash ||=
-        begin
-          bashrc = '/tmp/fzf.bash'
-          File.open(bashrc, 'w') do |f|
-            f.puts ERB.new(TEMPLATE).result(binding)
-          end
-
-          "bash --rcfile #{bashrc}"
-        end
-    end
-
-    def zsh
-      @zsh ||=
-        begin
-          zdotdir = '/tmp/fzf-zsh'
-          FileUtils.rm_rf(zdotdir)
-          FileUtils.mkdir_p(zdotdir)
-          File.open("#{zdotdir}/.zshrc", 'w') do |f|
-            f.puts ERB.new(TEMPLATE).result(binding)
-          end
-          "ZDOTDIR=#{zdotdir} zsh"
-        end
-    end
-
-    def fish
-      "unset #{UNSETS.join(' ')}; rm -f ~/.local/share/fish/fzf_test_history; FZF_DEFAULT_OPTS=\"--no-scrollbar --pointer '>' --marker '>'\" fish_history=fzf_test fish"
-    end
-  end
-end
-
-class Tmux
-  attr_reader :win
-
-  def initialize(shell = :bash)
-    @win = go(%W[new-window -d -P -F #I #{Shell.send(shell)}]).first
-    go(%W[set-window-option -t #{@win} pane-base-index 0])
-    return unless shell == :fish
-
-    send_keys 'function fish_prompt; end; clear', :Enter
-    self.until(&:empty?)
-  end
-
-  def kill
-    go(%W[kill-window -t #{win}])
-  end
-
-  def focus
-    go(%W[select-window -t #{win}])
-  end
-
-  def send_keys(*args)
-    go(%W[send-keys -t #{win}] + args.map(&:to_s))
-  end
-
-  def paste(str)
-    system('tmux', 'setb', str, ';', 'pasteb', '-t', win, ';', 'send-keys', '-t', win, 'Enter')
-  end
-
-  def capture
-    go(%W[capture-pane -p -J -t #{win}]).map(&:rstrip).reverse.drop_while(&:empty?).reverse
-  end
-
-  def until(refresh = false, timeout: DEFAULT_TIMEOUT)
-    lines = nil
-    begin
-      wait(timeout) do
-        lines = capture
-        class << lines
-          def counts
-            lazy
-              .map { |l| l.scan(%r{^. ([0-9]+)/([0-9]+)( \(([0-9]+)\))?}) }
-              .reject(&:empty?)
-              .first&.first&.map(&:to_i)&.values_at(0, 1, 3) || [0, 0, 0]
-          end
-
-          def match_count
-            counts[0]
-          end
-
-          def item_count
-            counts[1]
-          end
-
-          def select_count
-            counts[2]
-          end
-
-          def any_include?(val)
-            method = val.is_a?(Regexp) ? :match : :include?
-            find { |line| line.send(method, val) }
-          end
-        end
-        yield(lines).tap do |ok|
-          send_keys 'C-l' if refresh && !ok
-        end
-      end
-    rescue Minitest::Assertion
-      puts $ERROR_INFO.backtrace
-      puts '>' * 80
-      puts lines
-      puts '<' * 80
-      raise
-    end
-    lines
-  end
-
-  def prepare
-    tries = 0
-    begin
-      self.until(true) do |lines|
-        message = "Prepare[#{tries}]"
-        send_keys ' ', 'C-u', :Enter, message, :Left, :Right
-        lines[-1] == message
-      end
-    rescue Minitest::Assertion
-      (tries += 1) < 5 ? retry : raise
-    end
-    send_keys 'C-u', 'C-l'
-  end
-
-  private
-
-  def go(args)
-    IO.popen(%w[tmux] + args) { |io| io.readlines(chomp: true) }
-  end
-end
-
-class TestBase < Minitest::Test
-  TEMPNAME = Dir::Tmpname.create(%w[fzf]) {}
-  FIFONAME = Dir::Tmpname.create(%w[fzf-fifo]) {}
-
-  attr_reader :tmux
-
-  def writelines(lines)
-    File.write(TEMPNAME, lines.join("\n"))
-  end
-
-  def tempname
-    TEMPNAME
-  end
-
-  def fzf_output
-    @thread.join.value.chomp.tap { @thread = nil }
-  end
-
-  def fzf_output_lines
-    fzf_output.lines(chomp: true)
-  end
-
-  def setup
-    FileUtils.rm_f([TEMPNAME, FIFONAME])
-    File.mkfifo(FIFONAME)
-  end
-
-  def teardown
-    FileUtils.rm_f([TEMPNAME, FIFONAME])
-  end
-
-  alias assert_equal_org assert_equal
-  def assert_equal(expected, actual)
-    # Ignore info separator
-    actual = actual&.sub(/\s*─+$/, '') if actual.is_a?(String) && actual&.match?(%r{\d+/\d+})
-    assert_equal_org(expected, actual)
-  end
-
-  # Run fzf with its output piped to a fifo
-  def fzf(*opts)
-    raise 'fzf_output not taken' if @thread
-
-    @thread = Thread.new { File.read(FIFONAME) }
-    fzf!(*opts) + " > #{FIFONAME}"
-  end
-
-  def fzf!(*opts)
-    opts = opts.map do |o|
-      case o
-      when Symbol
-        o = o.to_s
-        o.length > 1 ? "--#{o.tr('_', '-')}" : "-#{o}"
-      when String, Numeric
-        o.to_s
-      end
-    end.compact
-    "#{FZF} #{opts.join(' ')}"
-  end
-end
-
-class TestGoFZF < TestBase
-  def setup
-    super
-    @tmux = Tmux.new
-  end
-
-  def teardown
-    super
-    @tmux.kill
-  end
-
-  def test_vanilla
-    tmux.send_keys "seq 1 100000 | #{fzf}", :Enter
-    tmux.until do |lines|
-      assert_equal '>', lines.last
-      assert_equal '  100000/100000', lines[-2]
-    end
-    lines = tmux.capture
-    assert_equal '  2',             lines[-4]
-    assert_equal '> 1',             lines[-3]
-    assert_equal '  100000/100000', lines[-2]
-    assert_equal '>',               lines[-1]
-
-    # Testing basic key bindings
-    tmux.send_keys '99', 'C-a', '1', 'C-f', '3', 'C-b', 'C-h', 'C-u', 'C-e', 'C-y', 'C-k', 'Tab', 'BTab'
-    tmux.until do |lines|
-      assert_equal '> 3910', lines[-4]
-      assert_equal '  391', lines[-3]
-      assert_equal '  856/100000', lines[-2]
-      assert_equal '> 391', lines[-1]
-    end
-
-    tmux.send_keys :Enter
-    assert_equal '3910', fzf_output
-  end
-
-  def test_fzf_default_command
-    tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND='echo hello'"), :Enter
-    tmux.until { |lines| assert_equal '> hello', lines[-3] }
-
-    tmux.send_keys :Enter
-    assert_equal 'hello', fzf_output
-  end
-
-  def test_fzf_default_command_failure
-    tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', 'FZF_DEFAULT_COMMAND=false'), :Enter
-    tmux.until { |lines| assert_includes lines[-2], '  [Command failed: false] ─' }
-    tmux.send_keys :Enter
-  end
-
-  def test_key_bindings
-    tmux.send_keys "#{FZF} -q 'foo bar foo-bar'", :Enter
-    tmux.until { |lines| assert_equal '> foo bar foo-bar', lines.last }
-
-    # CTRL-A
-    tmux.send_keys 'C-A', '('
-    tmux.until { |lines| assert_equal '> (foo bar foo-bar', lines.last }
-
-    # META-F
-    tmux.send_keys :Escape, :f, ')'
-    tmux.until { |lines| assert_equal '> (foo) bar foo-bar', lines.last }
-
-    # CTRL-B
-    tmux.send_keys 'C-B', 'var'
-    tmux.until { |lines| assert_equal '> (foovar) bar foo-bar', lines.last }
-
-    # Left, CTRL-D
-    tmux.send_keys :Left, :Left, 'C-D'
-    tmux.until { |lines| assert_equal '> (foovr) bar foo-bar', lines.last }
-
-    # META-BS
-    tmux.send_keys :Escape, :BSpace
-    tmux.until { |lines| assert_equal '> (r) bar foo-bar', lines.last }
-
-    # CTRL-Y
-    tmux.send_keys 'C-Y', 'C-Y'
-    tmux.until { |lines| assert_equal '> (foovfoovr) bar foo-bar', lines.last }
-
-    # META-B
-    tmux.send_keys :Escape, :b, :Space, :Space
-    tmux.until { |lines| assert_equal '> (  foovfoovr) bar foo-bar', lines.last }
-
-    # CTRL-F / Right
-    tmux.send_keys 'C-F', :Right, '/'
-    tmux.until { |lines| assert_equal '> (  fo/ovfoovr) bar foo-bar', lines.last }
-
-    # CTRL-H / BS
-    tmux.send_keys 'C-H', :BSpace
-    tmux.until { |lines| assert_equal '> (  fovfoovr) bar foo-bar', lines.last }
-
-    # CTRL-E
-    tmux.send_keys 'C-E', 'baz'
-    tmux.until { |lines| assert_equal '> (  fovfoovr) bar foo-barbaz', lines.last }
-
-    # CTRL-U
-    tmux.send_keys 'C-U'
-    tmux.until { |lines| assert_equal '>', lines.last }
-
-    # CTRL-Y
-    tmux.send_keys 'C-Y'
-    tmux.until { |lines| assert_equal '> (  fovfoovr) bar foo-barbaz', lines.last }
-
-    # CTRL-W
-    tmux.send_keys 'C-W', 'bar-foo'
-    tmux.until { |lines| assert_equal '> (  fovfoovr) bar bar-foo', lines.last }
-
-    # META-D
-    tmux.send_keys :Escape, :b, :Escape, :b, :Escape, :d, 'C-A', 'C-Y'
-    tmux.until { |lines| assert_equal '> bar(  fovfoovr) bar -foo', lines.last }
-
-    # CTRL-M
-    tmux.send_keys 'C-M'
-    tmux.until { |lines| refute_equal '>', lines.last }
-  end
-
-  def test_file_word
-    tmux.send_keys "#{FZF} -q '--/foo bar/foo-bar/baz' --filepath-word", :Enter
-    tmux.until { |lines| assert_equal '> --/foo bar/foo-bar/baz', lines.last }
-
-    tmux.send_keys :Escape, :b
-    tmux.send_keys :Escape, :b
-    tmux.send_keys :Escape, :b
-    tmux.send_keys :Escape, :d
-    tmux.send_keys :Escape, :f
-    tmux.send_keys :Escape, :BSpace
-    tmux.until { |lines| assert_equal '> --///baz', lines.last }
-  end
-
-  def test_multi_order
-    tmux.send_keys "seq 1 10 | #{fzf(:multi)}", :Enter
-    tmux.until { |lines| assert_equal '>', lines.last }
-
-    tmux.send_keys :Tab, :Up, :Up, :Tab, :Tab, :Tab, # 3, 2
-                   'C-K', 'C-K', 'C-K', 'C-K', :BTab, :BTab, # 5, 6
-                   :PgUp, 'C-J', :Down, :Tab, :Tab # 8, 7
-    tmux.until { |lines| assert_equal '  10/10 (6)', lines[-2] }
-    tmux.send_keys 'C-M'
-    assert_equal %w[3 2 5 6 8 7], fzf_output_lines
-  end
-
-  def test_multi_max
-    tmux.send_keys "seq 1 10 | #{FZF} -m 3 --bind A:select-all,T:toggle-all --preview 'echo [{+}]/{}'", :Enter
-
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-
-    tmux.send_keys '1'
-    tmux.until do |lines|
-      assert_includes lines[1], ' [1]/1 '
-      assert lines[-2]&.start_with?('  2/10 ')
-    end
-
-    tmux.send_keys 'A'
-    tmux.until do |lines|
-      assert_includes lines[1], ' [1 10]/1 '
-      assert lines[-2]&.start_with?('  2/10 (2/3)')
-    end
-
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (2/3)') }
-
-    tmux.send_keys 'T'
-    tmux.until do |lines|
-      assert_includes lines[1], ' [2 3 4]/1 '
-      assert lines[-2]&.start_with?('  10/10 (3/3)')
-    end
-
-    %w[T A].each do |key|
-      tmux.send_keys key
-      tmux.until do |lines|
-        assert_includes lines[1], ' [1 5 6]/1 '
-        assert lines[-2]&.start_with?('  10/10 (3/3)')
-      end
-    end
-
-    tmux.send_keys :BTab
-    tmux.until do |lines|
-      assert_includes lines[1], ' [5 6]/2 '
-      assert lines[-2]&.start_with?('  10/10 (2/3)')
-    end
-
-    [:BTab, :BTab, 'A'].each do |key|
-      tmux.send_keys key
-      tmux.until do |lines|
-        assert_includes lines[1], ' [5 6 2]/3 '
-        assert lines[-2]&.start_with?('  10/10 (3/3)')
-      end
-    end
-
-    tmux.send_keys '2'
-    tmux.until { |lines| assert lines[-2]&.start_with?('  1/10 (3/3)') }
-
-    tmux.send_keys 'T'
-    tmux.until do |lines|
-      assert_includes lines[1], ' [5 6]/2 '
-      assert lines[-2]&.start_with?('  1/10 (2/3)')
-    end
-
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (2/3)') }
-
-    tmux.send_keys 'A'
-    tmux.until do |lines|
-      assert_includes lines[1], ' [5 6 1]/1 '
-      assert lines[-2]&.start_with?('  10/10 (3/3)')
-    end
-  end
-
-  def test_multi_action
-    tmux.send_keys "seq 10 | #{FZF} --bind 'a:change-multi,b:change-multi(3),c:change-multi(xxx),d:change-multi(0)'", :Enter
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 ') }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (0)') }
-    tmux.send_keys 'b'
-    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (0/3)') }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (1/3)') }
-    tmux.send_keys 'c'
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert lines[-2]&.start_with?('  10/10 (2/3)') }
-    tmux.send_keys 'd'
-    tmux.until do |lines|
-      assert lines[-2]&.start_with?('  10/10 ') && !lines[-2]&.include?('(')
-    end
-  end
-
-  def test_with_nth
-    [true, false].each do |multi|
-      tmux.send_keys "(echo '  1st 2nd 3rd/';
-                       echo '  first second third/') |
-                       #{fzf(multi && :multi, :x, :nth, 2, :with_nth, '2,-1,1')}",
-                     :Enter
-      tmux.until { |lines| assert_equal multi ? '  2/2 (0)' : '  2/2', lines[-2] }
-
-      # Transformed list
-      lines = tmux.capture
-      assert_equal '  second third/first', lines[-4]
-      assert_equal '> 2nd 3rd/1st',        lines[-3]
-
-      # However, the output must not be transformed
-      if multi
-        tmux.send_keys :BTab, :BTab
-        tmux.until { |lines| assert_equal '  2/2 (2)', lines[-2] }
-        tmux.send_keys :Enter
-        assert_equal ['  1st 2nd 3rd/', '  first second third/'], fzf_output_lines
-      else
-        tmux.send_keys '^', '3'
-        tmux.until { |lines| assert_equal '  1/2', lines[-2] }
-        tmux.send_keys :Enter
-        assert_equal ['  1st 2nd 3rd/'], fzf_output_lines
-      end
-    end
-  end
-
-  def test_scroll
-    [true, false].each do |rev|
-      tmux.send_keys "seq 1 100 | #{fzf(rev && :reverse)}", :Enter
-      tmux.until { |lines| assert_equal '  100/100', lines[rev ? 1 : -2] }
-      tmux.send_keys(*Array.new(110) { rev ? :Down : :Up })
-      tmux.until { |lines| assert_includes lines, '> 100' }
-      tmux.send_keys :Enter
-      assert_equal '100', fzf_output
-    end
-  end
-
-  def test_select_1
-    tmux.send_keys "seq 1 100 | #{fzf(:with_nth, '..,..', :print_query, :q, 5555, :'1')}", :Enter
-    assert_equal %w[5555 55], fzf_output_lines
-  end
-
-  def test_exit_0
-    tmux.send_keys "seq 1 100 | #{fzf(:with_nth, '..,..', :print_query, :q, 555_555, :'0')}", :Enter
-    assert_equal %w[555555], fzf_output_lines
-  end
-
-  def test_select_1_exit_0_fail
-    [:'0', :'1', %i[1 0]].each do |opt|
-      tmux.send_keys "seq 1 100 | #{fzf(:print_query, :multi, :q, 5, *opt)}", :Enter
-      tmux.until { |lines| assert_equal '> 5', lines.last }
-      tmux.send_keys :BTab, :BTab, :BTab
-      tmux.until { |lines| assert_equal '  19/100 (3)', lines[-2] }
-      tmux.send_keys :Enter
-      assert_equal %w[5 5 50 51], fzf_output_lines
-    end
-  end
-
-  def test_query_unicode
-    tmux.paste "(echo abc; echo $'\\352\\260\\200\\353\\202\\230\\353\\213\\244') | #{fzf(:query, "$'\\352\\260\\200\\353\\213\\244'")}"
-    tmux.until { |lines| assert_equal '  1/2', lines[-2] }
-    tmux.send_keys :Enter
-    assert_equal %w[가나다], fzf_output_lines
-  end
-
-  def test_sync
-    tmux.send_keys "seq 1 100 | #{FZF} --multi | awk '{print $1 $1}' | #{fzf(:sync)}", :Enter
-    tmux.until { |lines| assert_equal '>', lines[-1] }
-    tmux.send_keys 9
-    tmux.until { |lines| assert_equal '  19/100 (0)', lines[-2] }
-    tmux.send_keys :BTab, :BTab, :BTab
-    tmux.until { |lines| assert_equal '  19/100 (3)', lines[-2] }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal '>', lines[-1] }
-    tmux.send_keys 'C-K', :Enter
-    assert_equal %w[9090], fzf_output_lines
-  end
-
-  def test_tac
-    tmux.send_keys "seq 1 1000 | #{fzf(:tac, :multi)}", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys :BTab, :BTab, :BTab
-    tmux.until { |lines| assert_equal '  1000/1000 (3)', lines[-2] }
-    tmux.send_keys :Enter
-    assert_equal %w[1000 999 998], fzf_output_lines
-  end
-
-  def test_tac_sort
-    tmux.send_keys "seq 1 1000 | #{fzf(:tac, :multi)}", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys '99'
-    tmux.until { |lines| assert_equal '  28/1000 (0)', lines[-2] }
-    tmux.send_keys :BTab, :BTab, :BTab
-    tmux.until { |lines| assert_equal '  28/1000 (3)', lines[-2] }
-    tmux.send_keys :Enter
-    assert_equal %w[99 999 998], fzf_output_lines
-  end
-
-  def test_tac_nosort
-    tmux.send_keys "seq 1 1000 | #{fzf(:tac, :no_sort, :multi)}", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys '00'
-    tmux.until { |lines| assert_equal '  10/1000 (0)', lines[-2] }
-    tmux.send_keys :BTab, :BTab, :BTab
-    tmux.until { |lines| assert_equal '  10/1000 (3)', lines[-2] }
-    tmux.send_keys :Enter
-    assert_equal %w[1000 900 800], fzf_output_lines
-  end
-
-  def test_expect
-    test = lambda do |key, feed, expected = key|
-      tmux.send_keys "seq 1 100 | #{fzf(:expect, key, :prompt, "[#{key}]")}", :Enter
-      tmux.until { |lines| assert_equal '  100/100', lines[-2] }
-      tmux.send_keys '55'
-      tmux.until { |lines| assert_equal '  1/100', lines[-2] }
-      tmux.send_keys(*feed)
-      tmux.prepare
-      assert_equal [expected, '55'], fzf_output_lines
-    end
-    test.call('ctrl-t', 'C-T')
-    test.call('ctrl-t', 'Enter', '')
-    test.call('alt-c', %i[Escape c])
-    test.call('f1', 'f1')
-    test.call('f2', 'f2')
-    test.call('f3', 'f3')
-    test.call('f2,f4', 'f2', 'f2')
-    test.call('f2,f4', 'f4', 'f4')
-    test.call('alt-/', %i[Escape /])
-    %w[f5 f6 f7 f8 f9 f10].each do |key|
-      test.call('f5,f6,f7,f8,f9,f10', key, key)
-    end
-    test.call('@', '@')
-  end
-
-  def test_expect_with_bound_actions
-    tmux.send_keys "seq 1 100 | #{fzf('--query 1 --print-query --expect z --bind z:up+up')}", :Enter
-    tmux.until { |lines| assert_equal 20, lines.match_count }
-    tmux.send_keys('z')
-    assert_equal %w[1 z 1], fzf_output_lines
-  end
-
-  def test_expect_print_query
-    tmux.send_keys "seq 1 100 | #{fzf('--expect=alt-z', :print_query)}", :Enter
-    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
-    tmux.send_keys '55'
-    tmux.until { |lines| assert_equal '  1/100', lines[-2] }
-    tmux.send_keys :Escape, :z
-    assert_equal %w[55 alt-z 55], fzf_output_lines
-  end
-
-  def test_expect_printable_character_print_query
-    tmux.send_keys "seq 1 100 | #{fzf('--expect=z --print-query')}", :Enter
-    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
-    tmux.send_keys '55'
-    tmux.until { |lines| assert_equal '  1/100', lines[-2] }
-    tmux.send_keys 'z'
-    assert_equal %w[55 z 55], fzf_output_lines
-  end
-
-  def test_expect_print_query_select_1
-    tmux.send_keys "seq 1 100 | #{fzf('-q55 -1 --expect=alt-z --print-query')}", :Enter
-    assert_equal ['55', '', '55'], fzf_output_lines
-  end
-
-  def test_toggle_sort
-    ['--toggle-sort=ctrl-r', '--bind=ctrl-r:toggle-sort'].each do |opt|
-      tmux.send_keys "seq 1 111 | #{fzf("-m +s --tac #{opt} -q11")}", :Enter
-      tmux.until { |lines| assert_equal '> 111', lines[-3] }
-      tmux.send_keys :Tab
-      tmux.until { |lines| assert_equal '  4/111 -S (1)', lines[-2] }
-      tmux.send_keys 'C-R'
-      tmux.until { |lines| assert_equal '> 11', lines[-3] }
-      tmux.send_keys :Tab
-      tmux.until { |lines| assert_equal '  4/111 +S (2)', lines[-2] }
-      tmux.send_keys :Enter
-      assert_equal %w[111 11], fzf_output_lines
-    end
-  end
-
-  def test_unicode_case
-    writelines(%w[строКА1 СТРОКА2 строка3 Строка4])
-    assert_equal %w[СТРОКА2 Строка4], `#{FZF} -fС < #{tempname}`.lines(chomp: true)
-    assert_equal %w[строКА1 СТРОКА2 строка3 Строка4], `#{FZF} -fс < #{tempname}`.lines(chomp: true)
-  end
-
-  def test_tiebreak
-    input = %w[
-      --foobar--------
-      -----foobar---
-      ----foobar--
-      -------foobar-
-    ]
-    writelines(input)
-
-    assert_equal input, `#{FZF} -ffoobar --tiebreak=index < #{tempname}`.lines(chomp: true)
-
-    by_length = %w[
-      ----foobar--
-      -----foobar---
-      -------foobar-
-      --foobar--------
-    ]
-    assert_equal by_length, `#{FZF} -ffoobar < #{tempname}`.lines(chomp: true)
-    assert_equal by_length, `#{FZF} -ffoobar --tiebreak=length < #{tempname}`.lines(chomp: true)
-
-    by_begin = %w[
-      --foobar--------
-      ----foobar--
-      -----foobar---
-      -------foobar-
-    ]
-    assert_equal by_begin, `#{FZF} -ffoobar --tiebreak=begin < #{tempname}`.lines(chomp: true)
-    assert_equal by_begin, `#{FZF} -f"!z foobar" -x --tiebreak begin < #{tempname}`.lines(chomp: true)
-
-    assert_equal %w[
-      -------foobar-
-      ----foobar--
-      -----foobar---
-      --foobar--------
-    ], `#{FZF} -ffoobar --tiebreak end < #{tempname}`.lines(chomp: true)
-
-    assert_equal input, `#{FZF} -f"!z" -x --tiebreak end < #{tempname}`.lines(chomp: true)
-  end
-
-  def test_tiebreak_index_begin
-    writelines([
-                 'xoxxxxxoxx',
-                 'xoxxxxxox',
-                 'xxoxxxoxx',
-                 'xxxoxoxxx',
-                 'xxxxoxox',
-                 '  xxoxoxxx'
-               ])
-
-    assert_equal [
-      'xxxxoxox',
-      '  xxoxoxxx',
-      'xxxoxoxxx',
-      'xxoxxxoxx',
-      'xoxxxxxox',
-      'xoxxxxxoxx'
-    ], `#{FZF} -foo < #{tempname}`.lines(chomp: true)
-
-    assert_equal [
-      'xxxoxoxxx',
-      'xxxxoxox',
-      '  xxoxoxxx',
-      'xxoxxxoxx',
-      'xoxxxxxoxx',
-      'xoxxxxxox'
-    ], `#{FZF} -foo --tiebreak=index < #{tempname}`.lines(chomp: true)
-
-    # Note that --tiebreak=begin is now based on the first occurrence of the
-    # first character on the pattern
-    assert_equal [
-      '  xxoxoxxx',
-      'xxxoxoxxx',
-      'xxxxoxox',
-      'xxoxxxoxx',
-      'xoxxxxxoxx',
-      'xoxxxxxox'
-    ], `#{FZF} -foo --tiebreak=begin < #{tempname}`.lines(chomp: true)
-
-    assert_equal [
-      '  xxoxoxxx',
-      'xxxoxoxxx',
-      'xxxxoxox',
-      'xxoxxxoxx',
-      'xoxxxxxox',
-      'xoxxxxxoxx'
-    ], `#{FZF} -foo --tiebreak=begin,length < #{tempname}`.lines(chomp: true)
-  end
-
-  def test_tiebreak_begin_algo_v2
-    writelines(['baz foo bar',
-                'foo bar baz'])
-    assert_equal [
-      'foo bar baz',
-      'baz foo bar'
-    ], `#{FZF} -fbar --tiebreak=begin --algo=v2 < #{tempname}`.lines(chomp: true)
-  end
-
-  def test_tiebreak_end
-    writelines(['xoxxxxxxxx',
-                'xxoxxxxxxx',
-                'xxxoxxxxxx',
-                'xxxxoxxxx',
-                'xxxxxoxxx',
-                '  xxxxoxxx'])
-
-    assert_equal [
-      '  xxxxoxxx',
-      'xxxxoxxxx',
-      'xxxxxoxxx',
-      'xoxxxxxxxx',
-      'xxoxxxxxxx',
-      'xxxoxxxxxx'
-    ], `#{FZF} -fo < #{tempname}`.lines(chomp: true)
-
-    assert_equal [
-      'xxxxxoxxx',
-      '  xxxxoxxx',
-      'xxxxoxxxx',
-      'xxxoxxxxxx',
-      'xxoxxxxxxx',
-      'xoxxxxxxxx'
-    ], `#{FZF} -fo --tiebreak=end < #{tempname}`.lines(chomp: true)
-
-    assert_equal [
-      'xxxxxoxxx',
-      '  xxxxoxxx',
-      'xxxxoxxxx',
-      'xxxoxxxxxx',
-      'xxoxxxxxxx',
-      'xoxxxxxxxx'
-    ], `#{FZF} -fo --tiebreak=end,length,begin < #{tempname}`.lines(chomp: true)
-
-    writelines(['/bar/baz', '/foo/bar/baz'])
-    assert_equal [
-      '/foo/bar/baz',
-      '/bar/baz'
-    ], `#{FZF} -fbaz --tiebreak=end < #{tempname}`.lines(chomp: true)
-  end
-
-  def test_tiebreak_length_with_nth
-    input = %w[
-      1:hell
-      123:hello
-      12345:he
-      1234567:h
-    ]
-    writelines(input)
-
-    output = %w[
-      1:hell
-      12345:he
-      123:hello
-      1234567:h
-    ]
-    assert_equal output, `#{FZF} -fh < #{tempname}`.lines(chomp: true)
-
-    # Since 0.16.8, --nth doesn't affect --tiebreak
-    assert_equal output, `#{FZF} -fh -n2 -d: < #{tempname}`.lines(chomp: true)
-  end
-
-  def test_tiebreak_chunk
-    writelines(['1 foobarbaz ba',
-                '2 foobar baz',
-                '3 foo barbaz'])
-
-    assert_equal [
-      '3 foo barbaz',
-      '2 foobar baz',
-      '1 foobarbaz ba'
-    ], `#{FZF} -fo --tiebreak=chunk < #{tempname}`.lines(chomp: true)
-
-    assert_equal [
-      '1 foobarbaz ba',
-      '2 foobar baz',
-      '3 foo barbaz'
-    ], `#{FZF} -fba --tiebreak=chunk < #{tempname}`.lines(chomp: true)
-
-    assert_equal [
-      '3 foo barbaz'
-    ], `#{FZF} -f'!foobar' --tiebreak=chunk < #{tempname}`.lines(chomp: true)
-  end
-
-  def test_invalid_cache
-    tmux.send_keys "(echo d; echo D; echo x) | #{fzf('-q d')}", :Enter
-    tmux.until { |lines| assert_equal '  2/3', lines[-2] }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal '  3/3', lines[-2] }
-    tmux.send_keys :D
-    tmux.until { |lines| assert_equal '  1/3', lines[-2] }
-    tmux.send_keys :Enter
-  end
-
-  def test_invalid_cache_query_type
-    command = %[(echo 'foo$bar'; echo 'barfoo'; echo 'foo^bar'; echo "foo'1-2"; seq 100) | #{FZF}]
-
-    # Suffix match
-    tmux.send_keys command, :Enter
-    tmux.until { |lines| assert_equal 104, lines.match_count }
-    tmux.send_keys 'foo$'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys 'bar'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Enter
-
-    # Prefix match
-    tmux.prepare
-    tmux.send_keys command, :Enter
-    tmux.until { |lines| assert_equal 104, lines.match_count }
-    tmux.send_keys '^bar'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys 'C-a', 'foo'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Enter
-
-    # Exact match
-    tmux.prepare
-    tmux.send_keys command, :Enter
-    tmux.until { |lines| assert_equal 104, lines.match_count }
-    tmux.send_keys "'12"
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys 'C-a', 'foo'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-  end
-
-  def test_smart_case_for_each_term
-    assert_equal 1, `echo Foo bar | #{FZF} -x -f "foo Fbar" | wc -l`.to_i
-  end
-
-  def test_bind
-    tmux.send_keys "seq 1 1000 | #{fzf('-m --bind=ctrl-j:accept,u:up,T:toggle-up,t:toggle')}", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys 'uuu', 'TTT', 'tt', 'uu', 'ttt', 'C-j'
-    assert_equal %w[4 5 6 9], fzf_output_lines
-  end
-
-  def test_bind_print_query
-    tmux.send_keys "seq 1 1000 | #{fzf('-m --bind=ctrl-j:print-query')}", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys 'print-my-query', 'C-j'
-    assert_equal %w[print-my-query], fzf_output_lines
-  end
-
-  def test_bind_replace_query
-    tmux.send_keys "seq 1 1000 | #{fzf('--print-query --bind=ctrl-j:replace-query')}", :Enter
-    tmux.send_keys '1'
-    tmux.until { |lines| assert_equal '  272/1000', lines[-2] }
-    tmux.send_keys 'C-k', 'C-j'
-    tmux.until { |lines| assert_equal '  29/1000', lines[-2] }
-    tmux.until { |lines| assert_equal '> 10', lines[-1] }
-  end
-
-  def test_long_line
-    data = '.' * 256 * 1024
-    File.open(tempname, 'w') do |f|
-      f << data
-    end
-    assert_equal data, `#{FZF} -f . < #{tempname}`.chomp
-  end
-
-  def test_read0
-    lines = `find .`.lines(chomp: true)
-    assert_equal lines.last, `find . | #{FZF} -e -f "^#{lines.last}$"`.chomp
-    assert_equal \
-      lines.last,
-      `find . -print0 | #{FZF} --read0 -e -f "^#{lines.last}$"`.chomp
-  end
-
-  def test_select_all_deselect_all_toggle_all
-    tmux.send_keys "seq 100 | #{fzf('--bind ctrl-a:select-all,ctrl-d:deselect-all,ctrl-t:toggle-all --multi')}", :Enter
-    tmux.until { |lines| assert_equal '  100/100 (0)', lines[-2] }
-    tmux.send_keys :BTab, :BTab, :BTab
-    tmux.until { |lines| assert_equal '  100/100 (3)', lines[-2] }
-    tmux.send_keys 'C-t'
-    tmux.until { |lines| assert_equal '  100/100 (97)', lines[-2] }
-    tmux.send_keys 'C-a'
-    tmux.until { |lines| assert_equal '  100/100 (100)', lines[-2] }
-    tmux.send_keys :Tab, :Tab
-    tmux.until { |lines| assert_equal '  100/100 (98)', lines[-2] }
-    tmux.send_keys '100'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys 'C-d'
-    tmux.until { |lines| assert_equal '  1/100 (97)', lines[-2] }
-    tmux.send_keys 'C-u'
-    tmux.until { |lines| assert_equal 100, lines.match_count }
-    tmux.send_keys 'C-d'
-    tmux.until { |lines| assert_equal '  100/100 (0)', lines[-2] }
-    tmux.send_keys :BTab, :BTab
-    tmux.until { |lines| assert_equal '  100/100 (2)', lines[-2] }
-    tmux.send_keys 0
-    tmux.until { |lines| assert_equal '  10/100 (2)', lines[-2] }
-    tmux.send_keys 'C-a'
-    tmux.until { |lines| assert_equal '  10/100 (12)', lines[-2] }
-    tmux.send_keys :Enter
-    assert_equal %w[1 2 10 20 30 40 50 60 70 80 90 100],
-                 fzf_output_lines
-  end
-
-  def test_history
-    history_file = '/tmp/fzf-test-history'
-
-    # History with limited number of entries
-    FileUtils.rm_f(history_file)
-    opts = "--history=#{history_file} --history-size=4"
-    input = %w[00 11 22 33 44]
-    input.each do |keys|
-      tmux.prepare
-      tmux.send_keys "seq 100 | #{FZF} #{opts}", :Enter
-      tmux.until { |lines| assert_equal '  100/100', lines[-2] }
-      tmux.send_keys keys
-      tmux.until { |lines| assert_equal '  1/100', lines[-2] }
-      tmux.send_keys :Enter
-    end
-    wait do
-      assert_path_exists history_file
-      assert_equal input[1..], File.readlines(history_file, chomp: true)
-    end
-
-    # Update history entries (not changed on disk)
-    tmux.send_keys "seq 100 | #{FZF} #{opts}", :Enter
-    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
-    tmux.send_keys 'C-p'
-    tmux.until { |lines| assert_equal '> 44', lines[-1] }
-    tmux.send_keys 'C-p'
-    tmux.until { |lines| assert_equal '> 33', lines[-1] }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal '> 3', lines[-1] }
-    tmux.send_keys 1
-    tmux.until { |lines| assert_equal '> 31', lines[-1] }
-    tmux.send_keys 'C-p'
-    tmux.until { |lines| assert_equal '> 22', lines[-1] }
-    tmux.send_keys 'C-n'
-    tmux.until { |lines| assert_equal '> 31', lines[-1] }
-    tmux.send_keys 0
-    tmux.until { |lines| assert_equal '> 310', lines[-1] }
-    tmux.send_keys :Enter
-    wait do
-      assert_path_exists history_file
-      assert_equal %w[22 33 44 310], File.readlines(history_file, chomp: true)
-    end
-
-    # Respect --bind option
-    tmux.send_keys "seq 100 | #{FZF} #{opts} --bind ctrl-p:next-history,ctrl-n:previous-history", :Enter
-    tmux.until { |lines| assert_equal '  100/100', lines[-2] }
-    tmux.send_keys 'C-n', 'C-n', 'C-n', 'C-n', 'C-p'
-    tmux.until { |lines| assert_equal '> 33', lines[-1] }
-    tmux.send_keys :Enter
-  ensure
-    FileUtils.rm_f(history_file)
-  end
-
-  def test_execute
-    output = '/tmp/fzf-test-execute'
-    opts = %[--bind "alt-a:execute(echo /{}/ >> #{output})+change-header(alt-a),alt-b:execute[echo /{}{}/ >> #{output}]+change-header(alt-b),C:execute(echo /{}{}{}/ >> #{output})+change-header(C)"]
-    writelines(%w[foo'bar foo"bar foo$bar])
-    tmux.send_keys "cat #{tempname} | #{FZF} #{opts}", :Enter
-    tmux.until { |lines| assert_equal 3, lines.item_count }
-
-    ready = ->(s) { tmux.until { |lines| assert_includes lines[-3], s } }
-    tmux.send_keys :Escape, :a
-    ready.call('alt-a')
-    tmux.send_keys :Escape, :b
-    ready.call('alt-b')
-
-    tmux.send_keys :Up
-    tmux.send_keys :Escape, :a
-    ready.call('alt-a')
-    tmux.send_keys :Escape, :b
-    ready.call('alt-b')
-
-    tmux.send_keys :Up
-    tmux.send_keys :C
-    ready.call('C')
-
-    tmux.send_keys 'barfoo'
-    tmux.until { |lines| assert_equal '  0/3', lines[-2] }
-
-    tmux.send_keys :Escape, :a
-    ready.call('alt-a')
-    tmux.send_keys :Escape, :b
-    ready.call('alt-b')
-
-    wait do
-      assert_path_exists output
-      assert_equal %w[
-        /foo'bar/ /foo'barfoo'bar/
-        /foo"bar/ /foo"barfoo"bar/
-        /foo$barfoo$barfoo$bar/
-      ], File.readlines(output, chomp: true)
-    end
-  ensure
-    FileUtils.rm_f(output)
-  end
-
-  def test_execute_multi
-    output = '/tmp/fzf-test-execute-multi'
-    opts = %[--multi --bind "alt-a:execute-multi(echo {}/{+} >> #{output})+change-header(alt-a),alt-b:change-header(alt-b)"]
-    writelines(%w[foo'bar foo"bar foo$bar foobar])
-    tmux.send_keys "cat #{tempname} | #{FZF} #{opts}", :Enter
-    ready = ->(s) { tmux.until { |lines| assert_includes lines[-3], s } }
-
-    tmux.until { |lines| assert_equal '  4/4 (0)', lines[-2] }
-    tmux.send_keys :Escape, :a
-    ready.call('alt-a')
-    tmux.send_keys :Escape, :b
-    ready.call('alt-b')
-
-    tmux.send_keys :BTab, :BTab, :BTab
-    tmux.until { |lines| assert_equal '  4/4 (3)', lines[-2] }
-    tmux.send_keys :Escape, :a
-    ready.call('alt-a')
-    tmux.send_keys :Escape, :b
-    ready.call('alt-b')
-
-    tmux.send_keys :Tab, :Tab
-    tmux.until { |lines| assert_equal '  4/4 (3)', lines[-2] }
-    tmux.send_keys :Escape, :a
-    ready.call('alt-a')
-    wait do
-      assert_path_exists output
-      assert_equal [
-        %(foo'bar/foo'bar),
-        %(foo'bar foo"bar foo$bar/foo'bar foo"bar foo$bar),
-        %(foo'bar foo"bar foobar/foo'bar foo"bar foobar)
-      ], File.readlines(output, chomp: true)
-    end
-  ensure
-    FileUtils.rm_f(output)
-  end
-
-  def test_execute_plus_flag
-    output = tempname + '.tmp'
-    FileUtils.rm_f(output)
-    writelines(['foo bar', '123 456'])
-
-    tmux.send_keys "cat #{tempname} | #{FZF} --multi --bind 'x:execute-silent(echo {+}/{}/{+2}/{2} >> #{output})'", :Enter
-
-    tmux.until { |lines| assert_equal '  2/2 (0)', lines[-2] }
-    tmux.send_keys 'xy'
-    tmux.until { |lines| assert_equal '  0/2 (0)', lines[-2] }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal '  2/2 (0)', lines[-2] }
-
-    tmux.send_keys :Up
-    tmux.send_keys :Tab
-    tmux.send_keys 'xy'
-    tmux.until { |lines| assert_equal '  0/2 (1)', lines[-2] }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal '  2/2 (1)', lines[-2] }
-
-    tmux.send_keys :Tab
-    tmux.send_keys 'xy'
-    tmux.until { |lines| assert_equal '  0/2 (2)', lines[-2] }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal '  2/2 (2)', lines[-2] }
-
-    wait do
-      assert_path_exists output
-      assert_equal [
-        %(foo bar/foo bar/bar/bar),
-        %(123 456/foo bar/456/bar),
-        %(123 456 foo bar/foo bar/456 bar/bar)
-      ], File.readlines(output, chomp: true)
-    end
-  rescue StandardError
-    FileUtils.rm_f(output)
-  end
-
-  def test_execute_shell
-    # Custom script to use as $SHELL
-    output = tempname + '.out'
-    FileUtils.rm_f(output)
-    writelines(['#!/usr/bin/env bash', "echo $1 / $2 > #{output}"])
-    system("chmod +x #{tempname}")
-
-    tmux.send_keys "echo foo | SHELL=#{tempname} fzf --bind 'enter:execute:{}bar'", :Enter
-    tmux.until { |lines| assert_equal '  1/1', lines[-2] }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal '  1/1', lines[-2] }
-    wait do
-      assert_path_exists output
-      assert_equal ["-c / 'foo'bar"], File.readlines(output, chomp: true)
-    end
-  ensure
-    FileUtils.rm_f(output)
-  end
-
-  def test_cycle
-    tmux.send_keys "seq 8 | #{FZF} --cycle", :Enter
-    tmux.until { |lines| assert_equal '  8/8', lines[-2] }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_equal '> 8', lines[-10] }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_equal '> 7', lines[-9] }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal '> 8', lines[-10] }
-    tmux.send_keys :PgUp
-    tmux.until { |lines| assert_equal '> 8', lines[-10] }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal '> 1', lines[-3] }
-    tmux.send_keys :PgDn
-    tmux.until { |lines| assert_equal '> 1', lines[-3] }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_equal '> 8', lines[-10] }
-  end
-
-  def test_header_lines
-    tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5')}", :Enter
-    2.times do
-      tmux.until do |lines|
-        assert_equal '  18/90', lines[-2]
-        assert_equal '  1', lines[-3]
-        assert_equal '  2', lines[-4]
-        assert_equal '> 50', lines[-13]
-      end
-      tmux.send_keys :Down
-    end
-    tmux.send_keys :Enter
-    assert_equal '50', fzf_output
-  end
-
-  def test_header_lines_reverse
-    tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5 --reverse')}", :Enter
-    2.times do
-      tmux.until do |lines|
-        assert_equal '  18/90', lines[1]
-        assert_equal '  1', lines[2]
-        assert_equal '  2', lines[3]
-        assert_equal '> 50', lines[12]
-      end
-      tmux.send_keys :Up
-    end
-    tmux.send_keys :Enter
-    assert_equal '50', fzf_output
-  end
-
-  def test_header_lines_reverse_list
-    tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5 --layout=reverse-list')}", :Enter
-    2.times do
-      tmux.until do |lines|
-        assert_equal '> 50', lines[0]
-        assert_equal '  2', lines[-4]
-        assert_equal '  1', lines[-3]
-        assert_equal '  18/90', lines[-2]
-      end
-      tmux.send_keys :Up
-    end
-    tmux.send_keys :Enter
-    assert_equal '50', fzf_output
-  end
-
-  def test_header_lines_overflow
-    tmux.send_keys "seq 100 | #{fzf('--header-lines=200')}", :Enter
-    tmux.until do |lines|
-      assert_equal '  0/0', lines[-2]
-      assert_equal '  1', lines[-3]
-    end
-    tmux.send_keys :Enter
-    assert_equal '', fzf_output
-  end
-
-  def test_header_lines_with_nth
-    tmux.send_keys "seq 100 | #{fzf('--header-lines 5 --with-nth 1,1,1,1,1')}", :Enter
-    tmux.until do |lines|
-      assert_equal '  95/95', lines[-2]
-      assert_equal '  11111', lines[-3]
-      assert_equal '  55555', lines[-7]
-      assert_equal '> 66666', lines[-8]
-    end
-    tmux.send_keys :Enter
-    assert_equal '6', fzf_output
-  end
-
-  def test_header
-    tmux.send_keys %[seq 100 | #{FZF} --header "$(head -5 #{FILE})"], :Enter
-    header = File.readlines(FILE, chomp: true).take(5)
-    tmux.until do |lines|
-      assert_equal '  100/100', lines[-2]
-      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7..-3]
-      assert_equal '> 1', lines[-8]
-    end
-  end
-
-  def test_header_reverse
-    tmux.send_keys %[seq 100 | #{FZF} --header "$(head -5 #{FILE})" --reverse], :Enter
-    header = File.readlines(FILE, chomp: true).take(5)
-    tmux.until do |lines|
-      assert_equal '  100/100', lines[1]
-      assert_equal header.map { |line| "  #{line}".rstrip }, lines[2..6]
-      assert_equal '> 1', lines[7]
-    end
-  end
-
-  def test_header_reverse_list
-    tmux.send_keys %[seq 100 | #{FZF} --header "$(head -5 #{FILE})" --layout=reverse-list], :Enter
-    header = File.readlines(FILE, chomp: true).take(5)
-    tmux.until do |lines|
-      assert_equal '  100/100', lines[-2]
-      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7..-3]
-      assert_equal '> 1', lines[0]
-    end
-  end
-
-  def test_header_and_header_lines
-    tmux.send_keys %[seq 100 | #{FZF} --header-lines 10 --header "$(head -5 #{FILE})"], :Enter
-    header = File.readlines(FILE, chomp: true).take(5)
-    tmux.until do |lines|
-      assert_equal '  90/90', lines[-2]
-      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7...-2]
-      assert_equal ('  1'..'  10').to_a.reverse, lines[-17...-7]
-    end
-  end
-
-  def test_header_and_header_lines_reverse
-    tmux.send_keys %[seq 100 | #{FZF} --reverse --header-lines 10 --header "$(head -5 #{FILE})"], :Enter
-    header = File.readlines(FILE, chomp: true).take(5)
-    tmux.until do |lines|
-      assert_equal '  90/90', lines[1]
-      assert_equal header.map { |line| "  #{line}".rstrip }, lines[2...7]
-      assert_equal ('  1'..'  10').to_a, lines[7...17]
-    end
-  end
-
-  def test_header_and_header_lines_reverse_list
-    tmux.send_keys %[seq 100 | #{FZF} --layout=reverse-list --header-lines 10 --header "$(head -5 #{FILE})"], :Enter
-    header = File.readlines(FILE, chomp: true).take(5)
-    tmux.until do |lines|
-      assert_equal '  90/90', lines[-2]
-      assert_equal header.map { |line| "  #{line}".rstrip }, lines[-7...-2]
-      assert_equal ('  1'..'  10').to_a.reverse, lines[-17...-7]
-    end
-  end
-
-  def test_toggle_header
-    tmux.send_keys "seq 4 | #{FZF} --header-lines 2 --header foo --bind space:toggle-header --header-first --height 10 --border rounded", :Enter
-    before = <<~OUTPUT
-      ╭───────
-      │
-      │   4
-      │ > 3
-      │   2/2
-      │ >
-      │   2
-      │   1
-      │   foo
-      ╰───────
-    OUTPUT
-    tmux.until { assert_block(before, _1) }
-    tmux.send_keys :Space
-    after = <<~OUTPUT
-      ╭───────
-      │
-      │
-      │
-      │
-      │   4
-      │ > 3
-      │   2/2
-      │ >
-      ╰───────
-    OUTPUT
-    tmux.until { assert_block(after, _1) }
-    tmux.send_keys :Space
-    tmux.until { assert_block(before, _1) }
-  end
-
-  def test_cancel
-    tmux.send_keys "seq 10 | #{FZF} --bind 2:cancel", :Enter
-    tmux.until { |lines| assert_equal '  10/10', lines[-2] }
-    tmux.send_keys '123'
-    tmux.until do |lines|
-      assert_equal '> 3', lines[-1]
-      assert_equal '  1/10', lines[-2]
-    end
-    tmux.send_keys 'C-y', 'C-y'
-    tmux.until { |lines| assert_equal '> 311', lines[-1] }
-    tmux.send_keys 2
-    tmux.until { |lines| assert_equal '>', lines[-1] }
-    tmux.send_keys 2
-    tmux.prepare
-  end
-
-  def test_margin
-    tmux.send_keys "yes | head -1000 | #{FZF} --margin 5,3", :Enter
-    tmux.until do |lines|
-      assert_equal '', lines[4]
-      assert_equal '     y', lines[5]
-    end
-    tmux.send_keys :Enter
-  end
-
-  def test_margin_reverse
-    tmux.send_keys "seq 1000 | #{FZF} --margin 7,5 --reverse", :Enter
-    tmux.until { |lines| assert_equal '       1000/1000', lines[1 + 7] }
-    tmux.send_keys :Enter
-  end
-
-  def test_margin_reverse_list
-    tmux.send_keys "yes | head -1000 | #{FZF} --margin 5,3 --layout=reverse-list", :Enter
-    tmux.until do |lines|
-      assert_equal '', lines[4]
-      assert_equal '   > y', lines[5]
-    end
-    tmux.send_keys :Enter
-  end
-
-  def test_tabstop
-    writelines(%W[f\too\tba\tr\tbaz\tbarfooq\tux])
-    {
-      1 => '> f oo ba r baz barfooq ux',
-      2 => '> f oo  ba  r baz barfooq ux',
-      3 => '> f  oo ba r  baz   barfooq  ux',
-      4 => '> f   oo  ba  r   baz barfooq ux',
-      5 => '> f    oo   ba   r    baz  barfooq   ux',
-      6 => '> f     oo    ba    r     baz   barfooq     ux',
-      7 => '> f      oo     ba     r      baz    barfooq       ux',
-      8 => '> f       oo      ba      r       baz     barfooq ux',
-      9 => '> f        oo       ba       r        baz      barfooq  ux'
-    }.each do |ts, exp|
-      tmux.prepare
-      tmux.send_keys %(cat #{tempname} | fzf --tabstop=#{ts}), :Enter
-      tmux.until(true) do |lines|
-        assert_equal exp, lines[-3]
-      end
-      tmux.send_keys :Enter
-    end
-  end
-
-  def test_with_nth_basic
-    writelines(['hello world ', 'byebye'])
-    assert_equal \
-      'hello world ',
-      `#{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 < #{tempname}`.chomp
-  end
-
-  def test_with_nth_ansi
-    writelines(["\x1b[33mhello \x1b[34;1mworld\x1b[m ", 'byebye'])
-    assert_equal \
-      'hello world ',
-      `#{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 --ansi < #{tempname}`.chomp
-  end
-
-  def test_with_nth_no_ansi
-    src = "\x1b[33mhello \x1b[34;1mworld\x1b[m "
-    writelines([src, 'byebye'])
-    assert_equal \
-      src,
-      `#{FZF} -fhehe -x -n 2.. --with-nth 2,1,1 --no-ansi < #{tempname}`.chomp
-  end
-
-  def test_exit_0_exit_code
-    `echo foo | #{FZF} -q bar -0`
-    assert_equal 1, $CHILD_STATUS.exitstatus
-  end
-
-  def test_invalid_option
-    lines = `#{FZF} --foobar 2>&1`
-    assert_equal 2, $CHILD_STATUS.exitstatus
-    assert_includes lines, 'unknown option: --foobar'
-  end
-
-  def test_filter_exitstatus
-    # filter / streaming filter
-    ['', '--no-sort'].each do |opts|
-      assert_includes `echo foo | #{FZF} -f foo #{opts}`, 'foo'
-      assert_equal 0, $CHILD_STATUS.exitstatus
-
-      assert_empty `echo foo | #{FZF} -f bar #{opts}`
-      assert_equal 1, $CHILD_STATUS.exitstatus
-    end
-  end
-
-  def test_exitstatus_empty
-    { '99' => '0', '999' => '1' }.each do |query, status|
-      tmux.send_keys "seq 100 | #{FZF} -q #{query}; echo --$?--", :Enter
-      tmux.until { |lines| assert_match %r{ [10]/100}, lines[-2] }
-      tmux.send_keys :Enter
-      tmux.until { |lines| assert_equal "--#{status}--", lines.last }
-    end
-  end
-
-  def test_default_extended
-    assert_equal '100', `seq 100 | #{FZF} -f "1 00$"`.chomp
-    assert_equal '', `seq 100 | #{FZF} -f "1 00$" +x`.chomp
-  end
-
-  def test_exact
-    assert_equal 4, `seq 123 | #{FZF} -f 13`.lines.length
-    assert_equal 2, `seq 123 | #{FZF} -f 13 -e`.lines.length
-    assert_equal 4, `seq 123 | #{FZF} -f 13 +e`.lines.length
-  end
-
-  def test_or_operator
-    assert_equal %w[1 5 10], `seq 10 | #{FZF} -f "1 | 5"`.lines(chomp: true)
-    assert_equal %w[1 10 2 3 4 5 6 7 8 9],
-                 `seq 10 | #{FZF} -f '1 | !1'`.lines(chomp: true)
-  end
-
-  def test_hscroll_off
-    writelines(['=' * 10_000 + '0123456789'])
-    [0, 3, 6].each do |off|
-      tmux.prepare
-      tmux.send_keys "#{FZF} --hscroll-off=#{off} -q 0 --bind space:toggle-hscroll < #{tempname}", :Enter
-      tmux.until { |lines| assert lines[-3]&.end_with?((0..off).to_a.join + '··') }
-      tmux.send_keys '9'
-      tmux.until { |lines| assert lines[-3]&.end_with?('789') }
-      tmux.send_keys :Space
-      tmux.until { |lines| assert lines[-3]&.end_with?('=··') }
-      tmux.send_keys :Space
-      tmux.until { |lines| assert lines[-3]&.end_with?('789') }
-      tmux.send_keys :Enter
-    end
-  end
-
-  def test_partial_caching
-    tmux.send_keys 'seq 1000 | fzf -e', :Enter
-    tmux.until { |lines| assert_equal '  1000/1000', lines[-2] }
-    tmux.send_keys 11
-    tmux.until { |lines| assert_equal '  19/1000', lines[-2] }
-    tmux.send_keys 'C-a', "'"
-    tmux.until { |lines| assert_equal '  28/1000', lines[-2] }
-    tmux.send_keys :Enter
-  end
-
-  def test_jump
-    tmux.send_keys "seq 1000 | #{fzf("--multi --jump-labels 12345 --bind 'ctrl-j:jump'")}", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys 'C-j'
-    tmux.until { |lines| assert_equal '5 5', lines[-7] }
-    tmux.until { |lines| assert_equal '  6', lines[-8] }
-    tmux.send_keys '5'
-    tmux.until { |lines| assert_equal '> 5', lines[-7] }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal ' >5', lines[-7] }
-    tmux.send_keys 'C-j'
-    tmux.until { |lines| assert_equal '5>5', lines[-7] }
-    tmux.send_keys '2'
-    tmux.until { |lines| assert_equal '> 2', lines[-4] }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal ' >2', lines[-4] }
-    tmux.send_keys 'C-j'
-    tmux.until { |lines| assert_equal '5>5', lines[-7] }
-
-    # Press any key other than jump labels to cancel jump
-    tmux.send_keys '6'
-    tmux.until { |lines| assert_equal '> 1', lines[-3] }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal '>>1', lines[-3] }
-    tmux.send_keys :Enter
-    assert_equal %w[5 2 1], fzf_output_lines
-  end
-
-  def test_jump_accept
-    tmux.send_keys "seq 1000 | #{fzf("--multi --jump-labels 12345 --bind 'ctrl-j:jump-accept'")}", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys 'C-j'
-    tmux.until { |lines| assert_equal '5 5', lines[-7] }
-    tmux.send_keys '3'
-    assert_equal '3', fzf_output
-  end
-
-  def test_jump_events
-    tmux.send_keys "seq 1000 | #{FZF} --multi --jump-labels 12345 --bind 'ctrl-j:jump,jump:preview(echo jumped to {}),jump-cancel:preview(echo jump cancelled at {})'", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000 (0)', lines[-2] }
-    tmux.send_keys 'C-j'
-    tmux.until { |lines| assert_includes lines[-7], '5 5' }
-    tmux.send_keys '3'
-    tmux.until { |lines| assert(lines.any? { _1.include?('jumped to 3') }) }
-    tmux.send_keys 'C-j'
-    tmux.until { |lines| assert_includes lines[-7], '5 5' }
-    tmux.send_keys 'C-c'
-    tmux.until { |lines| assert(lines.any? { _1.include?('jump cancelled at 3') }) }
-  end
-
-  def test_pointer
-    tmux.send_keys "seq 10 | #{fzf("--pointer '>>'")}", :Enter
-    # Assert that specified pointer is displayed
-    tmux.until { |lines| assert_equal '>> 1', lines[-3] }
-  end
-
-  def test_pointer_with_jump
-    tmux.send_keys "seq 10 | #{FZF} --multi --jump-labels 12345 --bind 'ctrl-j:jump' --pointer '>>'", :Enter
-    tmux.until { |lines| assert_equal '  10/10 (0)', lines[-2] }
-    tmux.send_keys 'C-j'
-    # Correctly padded jump label should appear
-    tmux.until { |lines| assert_equal '5  5', lines[-7] }
-    tmux.until { |lines| assert_equal '   6', lines[-8] }
-    tmux.send_keys '5'
-    # Assert that specified pointer is displayed
-    tmux.until { |lines| assert_equal '>> 5', lines[-7] }
-  end
-
-  def test_marker
-    tmux.send_keys "seq 10 | #{FZF} --multi --marker '>>'", :Enter
-    tmux.until { |lines| assert_equal '  10/10 (0)', lines[-2] }
-    tmux.send_keys :BTab
-    # Assert that specified marker is displayed
-    tmux.until { |lines| assert_equal ' >>1', lines[-3] }
-  end
-
-  def test_preview
-    tmux.send_keys %(seq 1000 | sed s/^2$// | #{FZF} -m --preview 'sleep 0.2; echo {{}-{+}}' --bind ?:toggle-preview), :Enter
-    tmux.until { |lines| assert_includes lines[1], ' {1-1} ' }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines[1], ' {-} ' }
-    tmux.send_keys '555'
-    tmux.until { |lines| assert_includes lines[1], ' {555-555} ' }
-    tmux.send_keys '?'
-    tmux.until { |lines| refute_includes lines[1], ' {555-555} ' }
-    tmux.send_keys '?'
-    tmux.until { |lines| assert_includes lines[1], ' {555-555} ' }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert lines[-2]&.start_with?('  28/1000 ') }
-    tmux.send_keys 'foobar'
-    tmux.until { |lines| refute_includes lines[1], ' {55-55} ' }
-    tmux.send_keys 'C-u'
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' {1-1} ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' {-1} ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' {3-1 } ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' {4-1  3} ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' {5-1  3 4} ' }
-  end
-
-  def test_toggle_preview_without_default_preview_command
-    tmux.send_keys %(seq 100 | #{FZF} --bind 'space:preview(echo [{}]),enter:toggle-preview' --preview-window up,border-double), :Enter
-    tmux.until do |lines|
-      assert_equal 100, lines.match_count
-      refute_includes lines[1], '║ [1]'
-    end
-
-    # toggle-preview should do nothing
-    tmux.send_keys :Enter
-    tmux.until { |lines| refute_includes lines[1], '║ [1]' }
-    tmux.send_keys :Up
-    tmux.until do |lines|
-      refute_includes lines[1], '║ [1]'
-      refute_includes lines[1], '║ [2]'
-    end
-
-    tmux.send_keys :Up
-    tmux.until do |lines|
-      assert_includes lines, '> 3'
-      refute_includes lines[1], '║ [3]'
-    end
-
-    # One-off preview action
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_includes lines[1], '║ [3]' }
-
-    # toggle-preview to hide it
-    tmux.send_keys :Enter
-    tmux.until { |lines| refute_includes lines[1], '║ [3]' }
-
-    # toggle-preview again does nothing
-    tmux.send_keys :Enter, :Up
-    tmux.until do |lines|
-      assert_includes lines, '> 4'
-      refute_includes lines[1], '║ [4]'
-    end
-  end
-
-  def test_show_and_hide_preview
-    tmux.send_keys %(seq 100 | #{FZF} --preview-window hidden,border-bold --preview 'echo [{}]' --bind 'a:show-preview,b:hide-preview'), :Enter
-
-    # Hidden by default
-    tmux.until do |lines|
-      assert_equal 100, lines.match_count
-      refute_includes lines[1], '┃ [1]'
-    end
-
-    # Show
-    tmux.send_keys :a
-    tmux.until { |lines| assert_includes lines[1], '┃ [1]' }
-
-    # Already shown
-    tmux.send_keys :a
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines[1], '┃ [2]' }
-
-    # Hide
-    tmux.send_keys :b
-    tmux.send_keys :Up
-    tmux.until do |lines|
-      assert_includes lines, '> 3'
-      refute_includes lines[1], '┃ [3]'
-    end
-
-    # Already hidden
-    tmux.send_keys :b
-    tmux.send_keys :Up
-    tmux.until do |lines|
-      assert_includes lines, '> 4'
-      refute_includes lines[1], '┃ [4]'
-    end
-
-    # Show it again
-    tmux.send_keys :a
-    tmux.until { |lines| assert_includes lines[1], '┃ [4]' }
-  end
-
-  def test_preview_hidden
-    tmux.send_keys %(seq 1000 | #{FZF} --preview 'echo {{}-{}-$FZF_PREVIEW_LINES-$FZF_PREVIEW_COLUMNS}' --preview-window down:1:hidden --bind ?:toggle-preview), :Enter
-    tmux.until { |lines| assert_equal '>', lines[-1] }
-    tmux.send_keys '?'
-    tmux.until { |lines| assert_match(/ {1-1-1-[0-9]+}/, lines[-2]) }
-    tmux.send_keys '555'
-    tmux.until { |lines| assert_match(/ {555-555-1-[0-9]+}/, lines[-2]) }
-    tmux.send_keys '?'
-    tmux.until { |lines| assert_equal '> 555', lines[-1] }
-  end
-
-  def test_preview_size_0
-    tmux.send_keys %(seq 100 | #{FZF} --reverse --preview 'echo {} >> #{tempname}; echo ' --preview-window 0 --bind space:toggle-preview), :Enter
-    tmux.until do |lines|
-      assert_equal 100, lines.item_count
-      assert_equal '  100/100', lines[1]
-      assert_equal '> 1', lines[2]
-    end
-    wait do
-      assert_path_exists tempname
-      assert_equal %w[1], File.readlines(tempname, chomp: true)
-    end
-    tmux.send_keys :Space, :Down, :Down
-    tmux.until { |lines| assert_equal '> 3', lines[4] }
-    wait do
-      assert_path_exists tempname
-      assert_equal %w[1], File.readlines(tempname, chomp: true)
-    end
-    tmux.send_keys :Space, :Down
-    tmux.until { |lines| assert_equal '> 4', lines[5] }
-    wait do
-      assert_path_exists tempname
-      assert_equal %w[1 3 4], File.readlines(tempname, chomp: true)
-    end
-  end
-
-  def test_preview_size_0_hidden
-    tmux.send_keys %(seq 100 | #{FZF} --reverse --preview 'echo {} >> #{tempname}; echo ' --preview-window 0,hidden --bind space:toggle-preview), :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys :Down, :Down
-    tmux.until { |lines| assert_includes lines, '> 3' }
-    wait { refute_path_exists tempname }
-    tmux.send_keys :Space
-    wait do
-      assert_path_exists tempname
-      assert_equal %w[3], File.readlines(tempname, chomp: true)
-    end
-    tmux.send_keys :Down
-    wait do
-      assert_equal %w[3 4], File.readlines(tempname, chomp: true)
-    end
-    tmux.send_keys :Space, :Down
-    tmux.until { |lines| assert_includes lines, '> 5' }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_includes lines, '> 6' }
-    tmux.send_keys :Space
-    wait do
-      assert_equal %w[3 4 6], File.readlines(tempname, chomp: true)
-    end
-  end
-
-  def test_preview_flags
-    tmux.send_keys %(seq 10 | sed 's/^/:: /; s/$/  /' |
-        #{FZF} --multi --preview 'echo {{2}/{s2}/{+2}/{+s2}/{q}/{n}/{+n}}'), :Enter
-    tmux.until { |lines| assert_includes lines[1], ' {1/1  /1/1  //0/0} ' }
-    tmux.send_keys '123'
-    tmux.until { |lines| assert_includes lines[1], ' {////123//} ' }
-    tmux.send_keys 'C-u', '1'
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' {1/1  /1/1  /1/0/0} ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' {10/10  /1/1  /1/9/0} ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' {10/10  /1 10/1   10  /1/9/0 9} ' }
-    tmux.send_keys '2'
-    tmux.until { |lines| assert_includes lines[1], ' {//1 10/1   10  /12//0 9} ' }
-    tmux.send_keys '3'
-    tmux.until { |lines| assert_includes lines[1], ' {//1 10/1   10  /123//0 9} ' }
-  end
-
-  def test_preview_file
-    tmux.send_keys %[(echo foo bar; echo bar foo) | #{FZF} --multi --preview 'cat {+f} {+f2} {+nf} {+fn}' --print0], :Enter
-    tmux.until { |lines| assert_includes lines[1], ' foo barbar00 ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' foo barbar00 ' }
-    tmux.send_keys :BTab
-    tmux.until { |lines| assert_includes lines[1], ' foo barbar foobarfoo0101 ' }
-  end
-
-  def test_preview_q_no_match
-    tmux.send_keys %(: | #{FZF} --preview 'echo foo {q} foo'), :Enter
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' foo  foo' }
-    tmux.send_keys 'bar'
-    tmux.until { |lines| assert_includes lines[1], ' foo bar foo' }
-    tmux.send_keys 'C-u'
-    tmux.until { |lines| assert_includes lines[1], ' foo  foo' }
-  end
-
-  def test_preview_q_no_match_with_initial_query
-    tmux.send_keys %(: | #{FZF} --preview 'echo foo {q}{q}' --query foo), :Enter
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' foofoo ' }
-  end
-
-  def test_no_clear
-    tmux.send_keys "seq 10 | #{fzf('--no-clear --inline-info --height 5')}", :Enter
-    prompt = '>   < 10/10'
-    tmux.until { |lines| assert_equal prompt, lines[-1] }
-    tmux.send_keys :Enter
-    assert_equal %w[1], fzf_output_lines
-    tmux.until { |lines| assert_equal prompt, lines[-1] }
-  end
-
-  def test_info_hidden
-    tmux.send_keys 'seq 10 | fzf --info=hidden --no-separator', :Enter
-    tmux.until { |lines| assert_equal '> 1', lines[-2] }
-  end
-
-  def test_info_inline_separator
-    tmux.send_keys 'seq 10 | fzf --info=inline:___ --no-separator', :Enter
-    tmux.until { |lines| assert_equal '>  ___10/10', lines[-1] }
-  end
-
-  def test_change_first_last
-    tmux.send_keys %(seq 1000 | #{FZF} --bind change:first,alt-Z:last), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal '> 2', lines[-4] }
-    tmux.send_keys 1
-    tmux.until { |lines| assert_equal '> 1', lines[-3] }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal '> 10', lines[-4] }
-    tmux.send_keys 1
-    tmux.until { |lines| assert_equal '> 11', lines[-3] }
-    tmux.send_keys 'C-u'
-    tmux.until { |lines| assert_equal '> 1', lines[-3] }
-    tmux.send_keys :Escape, 'Z'
-    tmux.until { |lines| assert_equal '> 1000', lines[0] }
-    tmux.send_keys :Enter
-  end
-
-  def test_pos
-    tmux.send_keys %(seq 1000 | #{FZF} --bind 'a:pos(3),b:pos(-3),c:pos(1),d:pos(-1),e:pos(0)' --preview 'echo {}/{}'), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys :a
-    tmux.until { |lines| assert_includes lines[1], ' 3/3' }
-    tmux.send_keys :b
-    tmux.until { |lines| assert_includes lines[1], ' 998/998' }
-    tmux.send_keys :c
-    tmux.until { |lines| assert_includes lines[1], ' 1/1' }
-    tmux.send_keys :d
-    tmux.until { |lines| assert_includes lines[1], ' 1000/1000' }
-    tmux.send_keys :e
-    tmux.until { |lines| assert_includes lines[1], ' 1/1' }
-  end
-
-  def test_put
-    tmux.send_keys %(seq 1000 | #{FZF} --bind 'a:put+put,b:put+put(ravo)' --preview 'echo {q}/{q}'), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys :a
-    tmux.until { |lines| assert_includes lines[1], ' aa/aa' }
-    tmux.send_keys :b
-    tmux.until { |lines| assert_includes lines[1], ' aabravo/aabravo' }
-  end
-
-  def test_accept_non_empty
-    tmux.send_keys %(seq 1000 | #{fzf('--print-query --bind enter:accept-non-empty')}), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys 'foo'
-    tmux.until { |lines| assert_equal '  0/1000', lines[-2] }
-    # fzf doesn't exit since there's no selection
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal '  0/1000', lines[-2] }
-    tmux.send_keys 'C-u'
-    tmux.until { |lines| assert_equal '  1000/1000', lines[-2] }
-    tmux.send_keys '999'
-    tmux.until { |lines| assert_equal '  1/1000', lines[-2] }
-    tmux.send_keys :Enter
-    assert_equal %w[999 999], fzf_output_lines
-  end
-
-  def test_accept_non_empty_with_multi_selection
-    tmux.send_keys %(seq 1000 | #{fzf('-m --print-query --bind enter:accept-non-empty')}), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal '  1000/1000 (1)', lines[-2] }
-    tmux.send_keys 'foo'
-    tmux.until { |lines| assert_equal '  0/1000 (1)', lines[-2] }
-    # fzf will exit in this case even though there's no match for the current query
-    tmux.send_keys :Enter
-    assert_equal %w[foo 1], fzf_output_lines
-  end
-
-  def test_accept_non_empty_with_empty_list
-    tmux.send_keys %(: | #{fzf('-q foo --print-query --bind enter:accept-non-empty')}), :Enter
-    tmux.until { |lines| assert_equal '  0/0', lines[-2] }
-    tmux.send_keys :Enter
-    # fzf will exit anyway since input list is empty
-    assert_equal %w[foo], fzf_output_lines
-  end
-
-  def test_accept_or_print_query_without_match
-    tmux.send_keys %(seq 1000 | #{fzf('--bind enter:accept-or-print-query')}), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys 99_999
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.send_keys :Enter
-    assert_equal %w[99999], fzf_output_lines
-  end
-
-  def test_accept_or_print_query_with_match
-    tmux.send_keys %(seq 1000 | #{fzf('--bind enter:accept-or-print-query')}), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys '^99$'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Enter
-    assert_equal %w[99], fzf_output_lines
-  end
-
-  def test_accept_or_print_query_with_multi_selection
-    tmux.send_keys %(seq 1000 | #{fzf('--bind enter:accept-or-print-query --multi')}), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys :BTab, :BTab, :BTab
-    tmux.until { |lines| assert_equal 3, lines.select_count }
-    tmux.send_keys 99_999
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.send_keys :Enter
-    assert_equal %w[1 2 3], fzf_output_lines
-  end
-
-  def test_preview_update_on_select
-    tmux.send_keys %(seq 10 | fzf -m --preview 'echo {+}' --bind a:toggle-all),
-                   :Enter
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert(lines.any? { |line| line.include?(' 1 2 3 4 5 ') }) }
-    tmux.send_keys 'a'
-    tmux.until { |lines| lines.each { |line| refute_includes line, ' 1 2 3 4 5 ' } }
-  end
-
-  def test_escaped_meta_characters
-    input = [
-      'foo^bar',
-      'foo$bar',
-      'foo!bar',
-      "foo'bar",
-      'foo bar',
-      'bar foo'
-    ]
-    writelines(input)
-
-    assert_equal input.length, `#{FZF} -f'foo bar' < #{tempname}`.lines.length
-    assert_equal input.length - 1, `#{FZF} -f'^foo bar$' < #{tempname}`.lines.length
-    assert_equal ['foo bar'], `#{FZF} -f'foo\\ bar' < #{tempname}`.lines(chomp: true)
-    assert_equal ['foo bar'], `#{FZF} -f'^foo\\ bar$' < #{tempname}`.lines(chomp: true)
-    assert_equal input.length - 1, `#{FZF} -f'!^foo\\ bar$' < #{tempname}`.lines.length
-  end
-
-  def test_inverse_only_search_should_not_sort_the_result
-    # Filter
-    assert_equal %w[aaaaa b ccc],
-                 `printf '%s\n' aaaaa b ccc BAD | #{FZF} -f '!bad'`.lines(chomp: true)
-
-    # Interactive
-    tmux.send_keys %(printf '%s\n' aaaaa b ccc BAD | #{FZF} -q '!bad'), :Enter
-    tmux.until do |lines|
-      assert_equal 4, lines.item_count
-      assert_equal 3, lines.match_count
-    end
-    tmux.until { |lines| assert_equal '> aaaaa', lines[-3] }
-    tmux.until { |lines| assert_equal '  b', lines[-4] }
-    tmux.until { |lines| assert_equal '  ccc', lines[-5] }
-  end
-
-  def test_preview_correct_tab_width_after_ansi_reset_code
-    writelines(["\x1b[31m+\x1b[m\t\x1b[32mgreen"])
-    tmux.send_keys "#{FZF} --preview 'cat #{tempname}'", :Enter
-    tmux.until { |lines| assert_includes lines[1], ' +       green ' }
-  end
-
-  def test_disabled
-    tmux.send_keys %(seq 1000 | #{FZF} --query 333 --disabled --bind a:enable-search,b:disable-search,c:toggle-search --preview 'echo {} {q}'), :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' 1 333 ' }
-    tmux.send_keys 'foo'
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' 1 333foo ' }
-
-    # Already disabled, no change
-    tmux.send_keys 'b'
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-
-    # Enable search
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.send_keys :BSpace, :BSpace, :BSpace
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' 333 333 ' }
-
-    # Toggle search -> disabled again, but retains the previous result
-    tmux.send_keys 'c'
-    tmux.send_keys 'foo'
-    tmux.until { |lines| assert_includes lines[1], ' 333 333foo ' }
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-
-    # Enabled, no match
-    tmux.send_keys 'c'
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], ' 333foo ' }
-  end
-
-  def test_reload
-    tmux.send_keys %(seq 1000 | #{FZF} --bind 'change:reload(seq $FZF_QUERY),a:reload(seq 100),b:reload:seq 200' --header-lines 2 --multi 2), :Enter
-    tmux.until { |lines| assert_equal 998, lines.match_count }
-    tmux.send_keys 'a'
-    tmux.until do |lines|
-      assert_equal 98, lines.item_count
-      assert_equal 98, lines.match_count
-    end
-    tmux.send_keys 'b'
-    tmux.until do |lines|
-      assert_equal 198, lines.item_count
-      assert_equal 198, lines.match_count
-    end
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal '  198/198 (1/2)', lines[-2] }
-    tmux.send_keys '555'
-    tmux.until { |lines| assert_equal '  1/553 (0/2)', lines[-2] }
-  end
-
-  def test_reload_even_when_theres_no_match
-    tmux.send_keys %(: | #{FZF} --bind 'space:reload(seq 10)'), :Enter
-    tmux.until { |lines| assert_equal 0, lines.item_count }
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-  end
-
-  def test_reload_should_terminate_standard_input_stream
-    tmux.send_keys %(ruby -e "STDOUT.sync = true; loop { puts 1; sleep 0.1 }" | fzf --bind 'start:reload(seq 100)'), :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-  end
-
-  def test_clear_list_when_header_lines_changed_due_to_reload
-    tmux.send_keys %(seq 10 | #{FZF} --header 0 --header-lines 3 --bind 'space:reload(seq 1)'), :Enter
-    tmux.until { |lines| assert_includes lines, '  9' }
-    tmux.send_keys :Space
-    tmux.until { |lines| refute_includes lines, '  9' }
-  end
-
-  def test_clear_query
-    tmux.send_keys %(: | #{FZF} --query foo --bind space:clear-query), :Enter
-    tmux.until { |lines| assert_equal 0, lines.item_count }
-    tmux.until { |lines| assert_equal '> foo', lines.last }
-    tmux.send_keys 'C-a', 'bar'
-    tmux.until { |lines| assert_equal '> barfoo', lines.last }
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_equal '>', lines.last }
-  end
-
-  def test_change_and_transform_header
-    [
-      'space:change-header:$(seq 4)',
-      'space:transform-header:seq 4'
-    ].each_with_index do |binding, i|
-      tmux.send_keys %(seq 3 | #{FZF} --header-lines 2 --header bar --bind "#{binding}"), :Enter
-      expected = <<~OUTPUT
-        > 3
-          2
-          1
-          bar
-          1/1
-        >
-      OUTPUT
-      tmux.until { assert_block(expected, _1) }
-      tmux.send_keys :Space
-      expected = <<~OUTPUT
-        > 3
-          2
-          1
-          1
-          2
-          3
-          4
-          1/1
-        >
-      OUTPUT
-      tmux.until { assert_block(expected, _1) }
-      next unless i.zero?
-
-      teardown
-      setup
-    end
-  end
-
-  def test_change_header
-    tmux.send_keys %(seq 3 | #{FZF} --header-lines 2 --header bar --bind "space:change-header:$(seq 4)"), :Enter
-    expected = <<~OUTPUT
-      > 3
-        2
-        1
-        bar
-        1/1
-      >
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-    tmux.send_keys :Space
-    expected = <<~OUTPUT
-      > 3
-        2
-        1
-        1
-        2
-        3
-        4
-        1/1
-      >
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_change_query
-    tmux.send_keys %(: | #{FZF} --query foo --bind space:change-query:foobar), :Enter
-    tmux.until { |lines| assert_equal 0, lines.item_count }
-    tmux.until { |lines| assert_equal '> foo', lines.last }
-    tmux.send_keys :Space, 'baz'
-    tmux.until { |lines| assert_equal '> foobarbaz', lines.last }
-  end
-
-  def test_transform_query
-    tmux.send_keys %{#{FZF} --bind 'ctrl-r:transform-query(rev <<< {q}),ctrl-u:transform-query: tr "[:lower:]" "[:upper:]" <<< {q}' --query bar}, :Enter
-    tmux.until { |lines| assert_equal '> bar', lines[-1] }
-    tmux.send_keys 'C-r'
-    tmux.until { |lines| assert_equal '> rab', lines[-1] }
-    tmux.send_keys 'C-u'
-    tmux.until { |lines| assert_equal '> RAB', lines[-1] }
-  end
-
-  def test_transform_prompt
-    tmux.send_keys %{#{FZF} --bind 'ctrl-r:transform-query(rev <<< {q}),ctrl-u:transform-query: tr "[:lower:]" "[:upper:]" <<< {q}' --query bar}, :Enter
-    tmux.until { |lines| assert_equal '> bar', lines[-1] }
-    tmux.send_keys 'C-r'
-    tmux.until { |lines| assert_equal '> rab', lines[-1] }
-    tmux.send_keys 'C-u'
-    tmux.until { |lines| assert_equal '> RAB', lines[-1] }
-  end
-
-  def test_transform
-    tmux.send_keys %{#{FZF} --bind 'focus:transform:echo "change-prompt({fzf:action})"'}, :Enter
-    tmux.until { |lines| assert_equal 'start', lines[-1] }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal 'up', lines[-1] }
-  end
-
-  def test_clear_selection
-    tmux.send_keys %(seq 100 | #{FZF} --multi --bind space:clear-selection), :Enter
-    tmux.until { |lines| assert_equal 100, lines.match_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal '  100/100 (1)', lines[-2] }
-    tmux.send_keys 'foo'
-    tmux.until { |lines| assert_equal '  0/100 (1)', lines[-2] }
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_equal '  0/100 (0)', lines[-2] }
-  end
-
-  def test_backward_delete_char_eof
-    tmux.send_keys "seq 1000 | #{FZF} --bind 'bs:backward-delete-char/eof'", :Enter
-    tmux.until { |lines| assert_equal '  1000/1000', lines[-2] }
-    tmux.send_keys '11'
-    tmux.until { |lines| assert_equal '> 11', lines[-1] }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal '> 1', lines[-1] }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal '>', lines[-1] }
-    tmux.send_keys :BSpace
-    tmux.prepare
-  end
-
-  def test_strip_xterm_osc_sequence
-    %W[\x07 \x1b\\].each do |esc|
-      writelines([%(printf $1"\e]4;3;rgb:aa/bb/cc#{esc} "$2)])
-      File.chmod(0o755, tempname)
-      tmux.prepare
-      tmux.send_keys \
-        %(echo foo bar | #{FZF} --preview '#{tempname} {2} {1}'), :Enter
-
-      tmux.until { |lines| assert lines.any_include?('bar foo') }
-      tmux.send_keys :Enter
-    end
-  end
-
-  def test_keep_right
-    tmux.send_keys "seq 10000 | #{FZF} --read0 --keep-right --no-multi-line --bind space:toggle-multi-line", :Enter
-    tmux.until { |lines| assert lines.any_include?('9999␊10000') }
-    tmux.send_keys :Space
-    tmux.until { |lines| assert lines.any_include?('> 1') }
-    tmux.send_keys :Space
-    tmux.until { |lines| assert lines.any_include?('9999␊10000') }
-  end
-
-  def test_backward_eof
-    tmux.send_keys "echo foo | #{FZF} --bind 'backward-eof:reload(seq 100)'", :Enter
-    tmux.until { |lines| lines.item_count == 1 && lines.match_count == 1 }
-    tmux.send_keys 'x'
-    tmux.until { |lines| lines.item_count == 1 && lines.match_count == 0 }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| lines.item_count == 1 && lines.match_count == 1 }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| lines.item_count == 100 && lines.match_count == 100 }
-  end
-
-  def test_preview_bindings_with_default_preview
-    tmux.send_keys "seq 10 | #{FZF} --preview 'echo [{}]' --bind 'a:preview(echo [{}{}]),b:preview(echo [{}{}{}]),c:refresh-preview'", :Enter
-    tmux.until { |lines| lines.item_count == 10 }
-    tmux.until { |lines| assert_includes lines[1], '[1]' }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_includes lines[1], '[11]' }
-    tmux.send_keys 'c'
-    tmux.until { |lines| assert_includes lines[1], '[1]' }
-    tmux.send_keys 'b'
-    tmux.until { |lines| assert_includes lines[1], '[111]' }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines[1], '[2]' }
-  end
-
-  def test_preview_bindings_without_default_preview
-    tmux.send_keys "seq 10 | #{FZF} --bind 'a:preview(echo [{}{}]),b:preview(echo [{}{}{}]),c:refresh-preview'", :Enter
-    tmux.until { |lines| lines.item_count == 10 }
-    tmux.until { |lines| refute_includes lines[1], '1' }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_includes lines[1], '[11]' }
-    tmux.send_keys 'c' # does nothing
-    tmux.until { |lines| assert_includes lines[1], '[11]' }
-    tmux.send_keys 'b'
-    tmux.until { |lines| assert_includes lines[1], '[111]' }
-    tmux.send_keys 9
-    tmux.until { |lines| lines.match_count == 1 }
-    tmux.until { |lines| refute_includes lines[1], '2' }
-    tmux.until { |lines| assert_includes lines[1], '[111]' }
-  end
-
-  def test_preview_scroll_begin_constant
-    tmux.send_keys "echo foo 123 321 | #{FZF} --preview 'seq 1000' --preview-window left:+123", :Enter
-    tmux.until { |lines| assert_match %r{1/1}, lines[-2] }
-    tmux.until { |lines| assert_match %r{123.*123/1000}, lines[1] }
-  end
-
-  def test_preview_scroll_begin_expr
-    tmux.send_keys "echo foo 123 321 | #{FZF} --preview 'seq 1000' --preview-window left:+{3}", :Enter
-    tmux.until { |lines| assert_match %r{1/1}, lines[-2] }
-    tmux.until { |lines| assert_match %r{321.*321/1000}, lines[1] }
-  end
-
-  def test_preview_scroll_begin_and_offset
-    ['echo foo 123 321', 'echo foo :123: 321'].each do |input|
-      tmux.send_keys "#{input} | #{FZF} --preview 'seq 1000' --preview-window left:+{2}-2", :Enter
-      tmux.until { |lines| assert_match %r{1/1}, lines[-2] }
-      tmux.until { |lines| assert_match %r{121.*121/1000}, lines[1] }
-      tmux.send_keys 'C-c'
-    end
-  end
-
-  def test_normalized_match
-    echoes = '(echo a; echo á; echo A; echo Á;)'
-    assert_equal %w[a á A Á], `#{echoes} | #{FZF} -f a`.lines.map(&:chomp)
-    assert_equal %w[á Á], `#{echoes} | #{FZF} -f á`.lines.map(&:chomp)
-    assert_equal %w[A Á], `#{echoes} | #{FZF} -f A`.lines.map(&:chomp)
-    assert_equal %w[Á], `#{echoes} | #{FZF} -f Á`.lines.map(&:chomp)
-  end
-
-  def test_preview_clear_screen
-    tmux.send_keys %{seq 100 | #{FZF} --preview 'for i in $(seq 300); do (( i % 200 == 0 )) && printf "\\033[2J"; echo "[$i]"; sleep 0.001; done'}, :Enter
-    tmux.until { |lines| lines.item_count == 100 }
-    tmux.until { |lines| lines[1]&.include?('[200]') }
-  end
-
-  def test_change_prompt
-    tmux.send_keys "#{FZF} --bind 'a:change-prompt(a> ),b:change-prompt:b> ' --query foo", :Enter
-    tmux.until { |lines| assert_equal '> foo', lines[-1] }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_equal 'a> foo', lines[-1] }
-    tmux.send_keys 'b'
-    tmux.until { |lines| assert_equal 'b> foo', lines[-1] }
-  end
-
-  def test_preview_window_follow
-    file = Tempfile.new('fzf-follow')
-    file.sync = true
-
-    tmux.send_keys %(seq 100 | #{FZF} --preview 'echo start; tail -f "#{file.path}"' --preview-window follow --bind 'up:preview-up,down:preview-down,space:change-preview-window:follow|nofollow' --preview-window '~4'), :Enter
-    tmux.until { |lines| lines.item_count == 100 }
-
-    # Write to the temporary file, and check if the preview window is showing
-    # the last line of the file
-    tmux.until { |lines| assert_includes lines[1], 'start' }
-    3.times { file.puts _1 } # header lines
-    1000.times { file.puts _1 }
-    tmux.until { |lines| assert_includes lines[1], '/1004' }
-    tmux.until { |lines| assert_includes lines[-2], '999' }
-
-    # Scroll the preview window and fzf should stop following the file content
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines[-2], '998' }
-    file.puts 'foo', 'bar'
-    tmux.until do |lines|
-      assert_includes lines[1], '/1006'
-      assert_includes lines[-2], '998'
-    end
-
-    # Scroll back to the bottom and fzf should start following the file again
-    %w[999 foo bar].each do |item|
-      wait do
-        tmux.send_keys :Down
-        tmux.until { |lines| assert_includes lines[-2], item }
-      end
-    end
-    file.puts 'baz'
-    tmux.until do |lines|
-      assert_includes lines[1], '/1007'
-      assert_includes lines[-2], 'baz'
-    end
-
-    # Scroll upwards to stop following
-    tmux.send_keys :Up
-    wait { assert_includes lines[-2], 'bar' }
-    file.puts 'aaa'
-    tmux.until do |lines|
-      assert_includes lines[1], '/1008'
-      assert_includes lines[-2], 'bar'
-    end
-
-    # Manually enable following
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_includes lines[-2], 'aaa' }
-    file.puts 'bbb'
-    tmux.until do |lines|
-      assert_includes lines[1], '/1009'
-      assert_includes lines[-2], 'bbb'
-    end
-
-    # Disable following
-    tmux.send_keys :Space
-    file.puts 'ccc', 'ddd'
-    tmux.until do |lines|
-      assert_includes lines[1], '/1011'
-      assert_includes lines[-2], 'bbb'
-    end
-  rescue StandardError
-    file.close
-    file.unlink
-  end
-
-  def test_toggle_preview_wrap
-    tmux.send_keys "#{FZF} --preview 'for i in $(seq $FZF_PREVIEW_COLUMNS); do echo -n .; done; echo wrapped; echo 2nd line' --bind ctrl-w:toggle-preview-wrap", :Enter
-    2.times do
-      tmux.until { |lines| assert_includes lines[2], '2nd line' }
-      tmux.send_keys 'C-w'
-      tmux.until do |lines|
-        assert_includes lines[2], 'wrapped'
-        assert_includes lines[3], '2nd line'
-      end
-      tmux.send_keys 'C-w'
-    end
-  end
-
-  def test_close
-    tmux.send_keys "seq 100 | #{FZF} --preview 'echo foo' --bind ctrl-c:close", :Enter
-    tmux.until { |lines| assert_equal 100, lines.match_count }
-    tmux.until { |lines| assert_includes lines[1], 'foo' }
-    tmux.send_keys 'C-c'
-    tmux.until { |lines| refute_includes lines[1], 'foo' }
-    tmux.send_keys '10'
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-    tmux.send_keys 'C-c'
-    tmux.send_keys 'C-l', 'closed'
-    tmux.until { |lines| assert_includes lines[0], 'closed' }
-  end
-
-  def test_select_deselect
-    tmux.send_keys "seq 3 | #{FZF} --multi --bind up:deselect+up,down:select+down", :Enter
-    tmux.until { |lines| assert_equal 3, lines.match_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal 1, lines.select_count }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal 0, lines.select_count }
-    tmux.send_keys :Down, :Down
-    tmux.until { |lines| assert_equal 2, lines.select_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal 1, lines.select_count }
-    tmux.send_keys :Down, :Down
-    tmux.until { |lines| assert_equal 2, lines.select_count }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal 1, lines.select_count }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_equal 1, lines.select_count }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_equal 2, lines.select_count }
-  end
-
-  def test_interrupt_execute
-    tmux.send_keys "seq 100 | #{FZF} --bind 'ctrl-l:execute:echo executing {}; sleep 100'", :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys 'C-l'
-    tmux.until { |lines| assert lines.any_include?('executing 1') }
-    tmux.send_keys 'C-c'
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys 99
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-  end
-
-  def test_kill_default_command_on_abort
-    writelines(['#!/usr/bin/env bash',
-                "echo 'Started'",
-                'while :; do sleep 1; done'])
-    system("chmod +x #{tempname}")
-
-    tmux.send_keys FZF.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND=#{tempname}"), :Enter
-    tmux.until { |lines| assert_equal 1, lines.item_count }
-    tmux.send_keys 'C-c'
-    tmux.send_keys 'C-l', 'closed'
-    tmux.until { |lines| assert_includes lines[0], 'closed' }
-    wait { refute system("pgrep -f #{tempname}") }
-  ensure
-    system("pkill -9 -f #{tempname}")
-  end
-
-  def test_kill_default_command_on_accept
-    writelines(['#!/usr/bin/env bash',
-                "echo 'Started'",
-                'while :; do sleep 1; done'])
-    system("chmod +x #{tempname}")
-
-    tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND=#{tempname}"), :Enter
-    tmux.until { |lines| assert_equal 1, lines.item_count }
-    tmux.send_keys :Enter
-    assert_equal 'Started', fzf_output
-    wait { refute system("pgrep -f #{tempname}") }
-  ensure
-    system("pkill -9 -f #{tempname}")
-  end
-
-  def test_kill_reload_command_on_abort
-    writelines(['#!/usr/bin/env bash',
-                "echo 'Started'",
-                'while :; do sleep 1; done'])
-    system("chmod +x #{tempname}")
-
-    tmux.send_keys "seq 1 3 | #{FZF} --bind 'ctrl-r:reload(#{tempname})'", :Enter
-    tmux.until { |lines| assert_equal 3, lines.item_count }
-    tmux.send_keys 'C-r'
-    tmux.until { |lines| assert_equal 1, lines.item_count }
-    tmux.send_keys 'C-c'
-    tmux.send_keys 'C-l', 'closed'
-    tmux.until { |lines| assert_includes lines[0], 'closed' }
-    wait { refute system("pgrep -f #{tempname}") }
-  ensure
-    system("pkill -9 -f #{tempname}")
-  end
-
-  def test_kill_reload_command_on_accept
-    writelines(['#!/usr/bin/env bash',
-                "echo 'Started'",
-                'while :; do sleep 1; done'])
-    system("chmod +x #{tempname}")
-
-    tmux.send_keys "seq 1 3 | #{fzf("--bind 'ctrl-r:reload(#{tempname})'")}", :Enter
-    tmux.until { |lines| assert_equal 3, lines.item_count }
-    tmux.send_keys 'C-r'
-    tmux.until { |lines| assert_equal 1, lines.item_count }
-    tmux.send_keys :Enter
-    assert_equal 'Started', fzf_output
-    wait { refute system("pgrep -f #{tempname}") }
-  ensure
-    system("pkill -9 -f #{tempname}")
-  end
-
-  def test_preview_header
-    tmux.send_keys "seq 100 | #{FZF} --bind ctrl-k:preview-up+preview-up,ctrl-j:preview-down+preview-down+preview-down --preview 'seq 1000' --preview-window 'top:+{1}:~3'", :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    top5 = ->(lines) { lines.drop(1).take(5).map { |s| s[/[0-9]+/] } }
-    tmux.until do |lines|
-      assert_includes lines[1], '4/1000'
-      assert_equal(%w[1 2 3 4 5], top5[lines])
-    end
-    tmux.send_keys '55'
-    tmux.until do |lines|
-      assert_equal 1, lines.match_count
-      assert_equal(%w[1 2 3 55 56], top5[lines])
-    end
-    tmux.send_keys 'C-J'
-    tmux.until do |lines|
-      assert_equal(%w[1 2 3 58 59], top5[lines])
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 19, lines.match_count
-      assert_equal(%w[1 2 3 5 6], top5[lines])
-    end
-    tmux.send_keys 'C-K'
-    tmux.until { |lines| assert_equal(%w[1 2 3 4 5], top5[lines]) }
-  end
-
-  def test_unbind_rebind
-    tmux.send_keys "seq 100 | #{FZF} --bind 'c:clear-query,d:unbind(c,d),e:rebind(c,d)'", :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys 'ab'
-    tmux.until { |lines| assert_equal '> ab', lines[-1] }
-    tmux.send_keys 'c'
-    tmux.until { |lines| assert_equal '>', lines[-1] }
-    tmux.send_keys 'dabcd'
-    tmux.until { |lines| assert_equal '> abcd', lines[-1] }
-    tmux.send_keys 'ecabddc'
-    tmux.until { |lines| assert_equal '> abdc', lines[-1] }
-  end
-
-  def test_item_index_reset_on_reload
-    tmux.send_keys "seq 10 | #{FZF} --preview 'echo [[{n}]]' --bind 'up:last,down:first,space:reload:seq 100'", :Enter
-    tmux.until { |lines| assert_includes lines[1], '[[0]]' }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines[1], '[[9]]' }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_includes lines[1], '[[0]]' }
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert_equal 100, lines.item_count
-      assert_includes lines[1], '[[0]]'
-    end
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines[1], '[[99]]' }
-  end
-
-  def test_reload_should_update_preview
-    tmux.send_keys "seq 3 | #{FZF} --bind 'ctrl-t:reload:echo 4' --preview 'echo {}' --preview-window 'nohidden'", :Enter
-    tmux.until { |lines| assert_includes lines[1], '1' }
-    tmux.send_keys 'C-t'
-    tmux.until { |lines| assert_includes lines[1], '4' }
-  end
-
-  def test_reload_and_change_preview_should_update_preview
-    tmux.send_keys "seq 3 | #{FZF} --bind 'ctrl-t:reload(echo 4)+change-preview(echo {})'", :Enter
-    tmux.until { |lines| assert_equal 3, lines.item_count }
-    tmux.until { |lines| refute_includes lines[1], '1' }
-    tmux.send_keys 'C-t'
-    tmux.until { |lines| assert_equal 1, lines.item_count }
-    tmux.until { |lines| assert_includes lines[1], '4' }
-  end
-
-  def test_reload_sync
-    tmux.send_keys "seq 100 | #{FZF} --bind 'load:reload-sync(sleep 1; seq 1000)+unbind(load)'", :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys '00'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    # After 1 second
-    tmux.until { |lines| assert_equal 10, lines.match_count }
-  end
-
-  def test_reload_disabled_case1
-    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload(sleep 2; seq 1000)'", :Enter
-    tmux.until do |lines|
-      assert_equal 100, lines.item_count
-      assert_equal 1, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-  end
-
-  def test_reload_disabled_case2
-    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload-sync(sleep 2; seq 1000)'", :Enter
-    tmux.until do |lines|
-      assert_equal 100, lines.item_count
-      assert_equal 1, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-  end
-
-  def test_reload_disabled_case3
-    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload(sleep 2; seq 1000)+backward-delete-char'", :Enter
-    tmux.until do |lines|
-      assert_equal 100, lines.item_count
-      assert_equal 1, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-  end
-
-  def test_reload_disabled_case4
-    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload-sync(sleep 2; seq 1000)+backward-delete-char'", :Enter
-    tmux.until do |lines|
-      assert_equal 100, lines.item_count
-      assert_equal 1, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-  end
-
-  def test_reload_disabled_case5
-    tmux.send_keys "seq 100 | #{FZF} --query 99 --bind 'space:disable-search+reload(echo xx; sleep 2; seq 1000)'", :Enter
-    tmux.until do |lines|
-      assert_equal 100, lines.item_count
-      assert_equal 1, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert_equal 1, lines.item_count
-      assert_equal 1, lines.match_count
-    end
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 1001, lines.match_count }
-  end
-
-  def test_reload_disabled_case6
-    tmux.send_keys "seq 1000 | #{FZF} --disabled --bind 'change:reload:sleep 0.5; seq {q}'", :Enter
-    tmux.until { |lines| assert_equal 1000, lines.match_count }
-    tmux.send_keys '9'
-    tmux.until { |lines| assert_equal 9, lines.match_count }
-    tmux.send_keys '9'
-    tmux.until { |lines| assert_equal 99, lines.match_count }
-
-    # TODO: How do we verify if an intermediate empty list is not shown?
-  end
-
-  def test_scroll_off
-    tmux.send_keys "seq 1000 | #{FZF} --scroll-off=3 --bind l:last", :Enter
-    tmux.until { |lines| assert_equal 1000, lines.item_count }
-    height = tmux.until { |lines| lines }.first.to_i
-    tmux.send_keys :PgUp
-    tmux.until do |lines|
-      assert_equal height + 3, lines.first.to_i
-      assert_equal "> #{height}", lines[3].strip
-    end
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal "> #{height + 1}", lines[3].strip }
-    tmux.send_keys 'l'
-    tmux.until { |lines| assert_equal '> 1000', lines.first.strip }
-    tmux.send_keys :PgDn
-    tmux.until { |lines| assert_equal "> #{1000 - height + 1}", lines.reverse[5].strip }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_equal "> #{1000 - height}", lines.reverse[5].strip }
-  end
-
-  def test_scroll_off_large
-    tmux.send_keys "seq 1000 | #{FZF} --scroll-off=9999", :Enter
-    tmux.until { |lines| assert_equal 1000, lines.item_count }
-    height = tmux.until { |lines| lines }.first.to_i
-    tmux.send_keys :PgUp
-    tmux.until { |lines| assert_equal "> #{height}", lines[height / 2].strip }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal "> #{height + 1}", lines[height / 2].strip }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal "> #{height + 2}", lines[height / 2].strip }
-    tmux.send_keys :Down
-    tmux.until { |lines| assert_equal "> #{height + 1}", lines[height / 2].strip }
-  end
-
-  def test_header_first
-    tmux.send_keys "seq 1000 | #{FZF} --header foobar --header-lines 3 --header-first", :Enter
-    tmux.until do |lines|
-      expected = <<~OUTPUT
-        > 4
-          997/997
-        >
-          3
-          2
-          1
-          foobar
-      OUTPUT
-
-      assert_equal expected.chomp, lines.reverse.take(7).reverse.join("\n")
-    end
-  end
-
-  def test_header_first_reverse
-    tmux.send_keys "seq 1000 | #{FZF} --header foobar --header-lines 3 --header-first --reverse --inline-info", :Enter
-    tmux.until do |lines|
-      expected = <<~OUTPUT
-          foobar
-          1
-          2
-          3
-        >   < 997/997
-        > 4
-      OUTPUT
-
-      assert_equal expected.chomp, lines.take(6).join("\n")
-    end
-  end
-
-  def test_change_preview_window
-    tmux.send_keys "seq 1000 | #{FZF} --preview 'echo [[{}]]' --no-preview-border --bind '" \
-      'a:change-preview(echo __{}__),' \
-      'b:change-preview-window(down)+change-preview(echo =={}==)+change-preview-window(up),' \
-      'c:change-preview(),d:change-preview-window(hidden),' \
-      "e:preview(printf ::%${FZF_PREVIEW_COLUMNS}s{})+change-preview-window(up),f:change-preview-window(up,wrap)'", :Enter
-    tmux.until { |lines| assert_equal 1000, lines.item_count }
-    tmux.until { |lines| assert_includes lines[0], '[[1]]' }
-
-    # change-preview action permanently changes the preview command set by --preview
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_includes lines[0], '__1__' }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines[0], '__2__' }
-
-    # When multiple change-preview-window actions are bound to a single key,
-    # the last one wins and the updated options are immediately applied to the new preview
-    tmux.send_keys 'b'
-    tmux.until { |lines| assert_equal '==2==', lines[0] }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_equal '==3==', lines[0] }
-
-    # change-preview with an empty preview command closes the preview window
-    tmux.send_keys 'c'
-    tmux.until { |lines| refute_includes lines[0], '==' }
-
-    # change-preview again to re-open the preview window
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_equal '__3__', lines[0] }
-
-    # Hide the preview window with hidden flag
-    tmux.send_keys 'd'
-    tmux.until { |lines| refute_includes lines[0], '__3__' }
-
-    # One-off preview
-    tmux.send_keys 'e'
-    tmux.until do |lines|
-      assert_equal '::', lines[0]
-      refute_includes lines[1], '3'
-    end
-
-    # Wrapped
-    tmux.send_keys 'f'
-    tmux.until do |lines|
-      assert_equal '::', lines[0]
-      assert_equal '  3', lines[1]
-    end
-  end
-
-  def test_change_preview_window_should_not_reset_change_preview
-    tmux.send_keys "#{FZF} --preview-window up,border-none --bind 'start:change-preview(echo hello)' --bind 'enter:change-preview-window(border-left)'", :Enter
-    tmux.until { |lines| assert_includes lines, 'hello' }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_includes lines, '│ hello' }
-  end
-
-  def test_change_preview_window_rotate
-    tmux.send_keys "seq 100 | #{FZF} --preview-window left,border-none --preview 'echo hello' --bind '" \
-      "a:change-preview-window(right|down|up|hidden|)'", :Enter
-    tmux.until { |lines| assert(lines.any? { _1.include?('100/100') }) }
-    3.times do
-      tmux.until { |lines| lines[0].start_with?('hello') }
-      tmux.send_keys 'a'
-      tmux.until { |lines| lines[0].end_with?('hello') }
-      tmux.send_keys 'a'
-      tmux.until { |lines| lines[-1].start_with?('hello') }
-      tmux.send_keys 'a'
-      tmux.until { |lines| assert_equal 'hello', lines[0] }
-      tmux.send_keys 'a'
-      tmux.until { |lines| refute_includes lines[0], 'hello' }
-      tmux.send_keys 'a'
-    end
-  end
-
-  def test_change_preview_window_rotate_hidden
-    tmux.send_keys "seq 100 | #{FZF} --preview-window hidden --preview 'echo =={}==' --bind '" \
-      "a:change-preview-window(nohidden||down,1|)'", :Enter
-    tmux.until { |lines| assert_equal 100, lines.match_count }
-    tmux.until { |lines| refute_includes lines[1], '==1==' }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_includes lines[1], '==1==' }
-    tmux.send_keys 'a'
-    tmux.until { |lines| refute_includes lines[1], '==1==' }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_includes lines[-2], '==1==' }
-    tmux.send_keys 'a'
-    tmux.until { |lines| refute_includes lines[-2], '==1==' }
-    tmux.send_keys 'a'
-    tmux.until { |lines| assert_includes lines[1], '==1==' }
-  end
-
-  def test_change_preview_window_rotate_hidden_down
-    tmux.send_keys "seq 100 | #{FZF} --bind '?:change-preview-window:up||down|' --preview 'echo =={}==' --preview-window hidden,down,1", :Enter
-    tmux.until { |lines| assert_equal 100, lines.match_count }
-    tmux.until { |lines| refute_includes lines[1], '==1==' }
-    tmux.send_keys '?'
-    tmux.until { |lines| assert_includes lines[1], '==1==' }
-    tmux.send_keys '?'
-    tmux.until { |lines| refute_includes lines[1], '==1==' }
-    tmux.send_keys '?'
-    tmux.until { |lines| assert_includes lines[-2], '==1==' }
-    tmux.send_keys '?'
-    tmux.until { |lines| refute_includes lines[-2], '==1==' }
-    tmux.send_keys '?'
-    tmux.until { |lines| assert_includes lines[1], '==1==' }
-  end
-
-  def test_ellipsis
-    tmux.send_keys 'seq 1000 | tr "\n" , | fzf --ellipsis=SNIPSNIP -e -q500', :Enter
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.until { |lines| assert_match(/^> SNIPSNIP.*SNIPSNIP$/, lines[-3]) }
-  end
-
-  def assert_block(expected, lines)
-    cols = expected.lines.map(&:chomp).map(&:length).max
-    top = lines.take(expected.lines.length).map { _1[0, cols].rstrip + "\n" }.join
-    bottom = lines.reverse.take(expected.lines.length).reverse.map { _1[0, cols].rstrip + "\n" }.join
-    assert_includes [top, bottom], expected
-  end
-
-  def test_height_range_fit
-    tmux.send_keys 'seq 3 | fzf --height ~100% --info=inline --border rounded', :Enter
-    expected = <<~OUTPUT
-      ╭──────────
-      │   3
-      │   2
-      │ > 1
-      │ >   < 3/3
-      ╰──────────
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_height_range_fit_preview_above
-    tmux.send_keys 'seq 3 | fzf --height ~100% --info=inline --border rounded --preview-window border-rounded --preview "seq {}" --preview-window up,60%', :Enter
-    expected = <<~OUTPUT
-      ╭──────────
-      │ ╭────────
-      │ │ 1
-      │ │
-      │ │
-      │ │
-      │ ╰────────
-      │   3
-      │   2
-      │ > 1
-      │ >   < 3/3
-      ╰──────────
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_height_range_fit_preview_above_alternative
-    tmux.send_keys 'seq 3 | fzf --height ~100% --border=sharp --preview "seq {}" --preview-window up,40%,border-bottom --padding 1 --exit-0 --header hello --header-lines=2', :Enter
-    expected = <<~OUTPUT
-      ┌─────────
-      │
-      │  1
-      │  2
-      │  3
-      │  ───────
-      │  > 3
-      │    2
-      │    1
-      │    hello
-      │    1/1 ─
-      │  >
-      │
-      └─────────
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_height_range_fit_preview_left
-    tmux.send_keys "seq 3 | fzf --height ~100% --border=vertical --preview 'seq {}' --preview-window left,5,border-right --padding 1 --exit-0 --header $'hello\\nworld' --header-lines=2", :Enter
-    expected = <<~OUTPUT
-      │
-      │  1     │ > 3
-      │  2     │   2
-      │  3     │   1
-      │        │   hello
-      │        │   world
-      │        │   1/1 ─
-      │        │ >
-      │
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_height_range_overflow
-    tmux.send_keys 'seq 100 | fzf --height ~5 --info=inline --border rounded', :Enter
-    expected = <<~OUTPUT
-      ╭──────────────
-      │   2
-      │ > 1
-      │ >   < 100/100
-      ╰──────────────
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_start_event
-    tmux.send_keys 'seq 100 | fzf --multi --sync --preview-window hidden:border-none --bind "start:select-all+last+preview(echo welcome)"', :Enter
-    tmux.until do |lines|
-      assert_match(/>100.*welcome/, lines[0])
-      assert_includes(lines[-2], '100/100 (100)')
-    end
-  end
-
-  def test_focus_event
-    tmux.send_keys 'seq 100 | fzf --bind "focus:transform-prompt(echo [[{}]]),?:unbind(focus)"', :Enter
-    tmux.until { |lines| assert_includes(lines[-1], '[[1]]') }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes(lines[-1], '[[2]]') }
-    tmux.send_keys :X
-    tmux.until { |lines| assert_includes(lines[-1], '[[]]') }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_includes(lines[-1], '[[1]]') }
-    tmux.send_keys :X
-    tmux.until { |lines| assert_includes(lines[-1], '[[]]') }
-    tmux.send_keys '?'
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 100, lines.match_count }
-    tmux.until { |lines| refute_includes(lines[-1], '[[1]]') }
-  end
-
-  def test_result_event
-    tmux.send_keys '(echo 0; seq 10) | fzf --bind "result:pos(2)"', :Enter
-    tmux.until { |lines| assert_equal 11, lines.item_count }
-    tmux.until { |lines| assert_includes lines, '> 1' }
-    tmux.send_keys '9'
-    tmux.until { |lines| assert_includes lines, '> 9' }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_includes lines, '> 1' }
-  end
-
-  def test_labels_center
-    tmux.send_keys 'echo x | fzf --border --border-label foobar --preview : --preview-label barfoo --bind "space:change-border-label(foobarfoo)+change-preview-label(barfoobar),enter:transform-border-label(echo foo{}foo)+transform-preview-label(echo bar{}bar)"', :Enter
-    tmux.until do
-      assert_includes(_1[0], '─foobar─')
-      assert_includes(_1[1], '─barfoo─')
-    end
-    tmux.send_keys :space
-    tmux.until do
-      assert_includes(_1[0], '─foobarfoo─')
-      assert_includes(_1[1], '─barfoobar─')
-    end
-    tmux.send_keys :Enter
-    tmux.until do
-      assert_includes(_1[0], '─fooxfoo─')
-      assert_includes(_1[1], '─barxbar─')
-    end
-  end
-
-  def test_labels_left
-    tmux.send_keys ': | fzf --border rounded --preview-window border-rounded --border-label foobar --border-label-pos 2 --preview : --preview-label barfoo --preview-label-pos 2', :Enter
-    tmux.until do
-      assert_includes(_1[0], '╭foobar─')
-      assert_includes(_1[1], '╭barfoo─')
-    end
-  end
-
-  def test_labels_right
-    tmux.send_keys ': | fzf --border rounded --preview-window border-rounded --border-label foobar --border-label-pos -2 --preview : --preview-label barfoo --preview-label-pos -2', :Enter
-    tmux.until do
-      assert_includes(_1[0], '─foobar╮')
-      assert_includes(_1[1], '─barfoo╮')
-    end
-  end
-
-  def test_labels_bottom
-    tmux.send_keys ': | fzf --border rounded --preview-window border-rounded --border-label foobar --border-label-pos 2:bottom --preview : --preview-label barfoo --preview-label-pos -2:bottom', :Enter
-    tmux.until do
-      assert_includes(_1[-1], '╰foobar─')
-      assert_includes(_1[-2], '─barfoo╯')
-    end
-  end
-
-  def test_labels_variables
-    tmux.send_keys ': | fzf --border --border-label foobar --preview "echo \$FZF_BORDER_LABEL // \$FZF_PREVIEW_LABEL" --preview-label barfoo --bind "space:change-border-label(barbaz)+change-preview-label(bazbar)+refresh-preview,enter:transform-border-label(echo 123)+transform-preview-label(echo 456)+refresh-preview"', :Enter
-    tmux.until do
-      assert_includes(_1[0], '─foobar─')
-      assert_includes(_1[1], '─barfoo─')
-      assert_includes(_1[2], ' foobar // barfoo ')
-    end
-    tmux.send_keys :Space
-    tmux.until do
-      assert_includes(_1[0], '─barbaz─')
-      assert_includes(_1[1], '─bazbar─')
-      assert_includes(_1[2], ' barbaz // bazbar ')
-    end
-    tmux.send_keys :Enter
-    tmux.until do
-      assert_includes(_1[0], '─123─')
-      assert_includes(_1[1], '─456─')
-      assert_includes(_1[2], ' 123 // 456 ')
-    end
-  end
-
-  def test_info_separator_unicode
-    tmux.send_keys 'seq 100 | fzf -q55', :Enter
-    tmux.until { assert_includes(_1[-2], '  1/100 ─') }
-  end
-
-  def test_info_separator_no_unicode
-    tmux.send_keys 'seq 100 | fzf -q55 --no-unicode', :Enter
-    tmux.until { assert_includes(_1[-2], '  1/100 -') }
-  end
-
-  def test_info_separator_repeat
-    tmux.send_keys 'seq 100 | fzf -q55 --separator _-', :Enter
-    tmux.until { assert_includes(_1[-2], '  1/100 _-_-') }
-  end
-
-  def test_info_separator_ansi_colors_and_tabs
-    tmux.send_keys "seq 100 | fzf -q55 --tabstop 4 --separator $'\\x1b[33ma\\tb'", :Enter
-    tmux.until { assert_includes(_1[-2], '  1/100 a   ba   ba') }
-  end
-
-  def test_info_no_separator
-    tmux.send_keys 'seq 100 | fzf -q55 --no-separator', :Enter
-    tmux.until { assert(_1[-2] == '  1/100') }
-  end
-
-  def test_info_right
-    tmux.send_keys "#{FZF} --info=right --separator x --bind 'start:reload:seq 100; sleep 10'", :Enter
-    tmux.until { assert_match(%r{xxx [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏] 100/100}, _1[-2]) }
-  end
-
-  def test_info_inline_right
-    tmux.send_keys "#{FZF} --info=inline-right --bind 'start:reload:seq 100; sleep 10'", :Enter
-    tmux.until { assert_match(%r{[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏] 100/100}, _1[-1]) }
-  end
-
-  def test_info_inline_right_clearance
-    tmux.send_keys "seq 100000 | #{FZF} --info inline-right", :Enter
-    tmux.until { assert_match(%r{100000/100000}, _1[-1]) }
-    tmux.send_keys 'x'
-    tmux.until { assert_match(%r{     0/100000}, _1[-1]) }
-  end
-
-  def test_info_command
-    tmux.send_keys(%(seq 10000 | #{FZF} --separator x --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"'), :Enter)
-    tmux.until { assert_match(%r{^  --1/10000/10000-- xx}, _1[-2]) }
-    tmux.send_keys :Up
-    tmux.until { assert_match(%r{^  --2/10000/10000-- xx}, _1[-2]) }
-  end
-
-  def test_info_command_inline
-    tmux.send_keys(%(seq 10000 | #{FZF} --separator x --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"' --info inline:xx), :Enter)
-    tmux.until { assert_match(%r{^>  xx--1/10000/10000-- xx}, _1[-1]) }
-  end
-
-  def test_info_command_right
-    tmux.send_keys(%(seq 10000 | #{FZF} --separator x --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"' --info right), :Enter)
-    tmux.until { assert_match(%r{xx --1/10000/10000-- *$}, _1[-2]) }
-  end
-
-  def test_info_command_inline_right
-    tmux.send_keys(%(seq 10000 | #{FZF} --info-command 'echo -e "--\\x1b[33m$FZF_POS\\x1b[m/$FZF_INFO--"' --info inline-right), :Enter)
-    tmux.until { assert_match(%r{   --1/10000/10000-- *$}, _1[-1]) }
-  end
-
-  def test_info_command_and_focus
-    tmux.send_keys(%(seq 100 | #{FZF} --separator x --info-command 'echo $FZF_POS' --bind focus:clear-query), :Enter)
-    tmux.until { assert_match(/^  1 xx/, _1[-2]) }
-    tmux.send_keys :Up
-    tmux.until { assert_match(/^  2 xx/, _1[-2]) }
-  end
-
-  def test_prev_next_selected
-    tmux.send_keys 'seq 10 | fzf --multi --bind ctrl-n:next-selected,ctrl-p:prev-selected', :Enter
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-    tmux.send_keys :BTab, :BTab, :Up, :BTab
-    tmux.until { |lines| assert_equal 3, lines.select_count }
-    tmux.send_keys 'C-n'
-    tmux.until { |lines| assert_includes lines, '>>4' }
-    tmux.send_keys 'C-n'
-    tmux.until { |lines| assert_includes lines, '>>2' }
-    tmux.send_keys 'C-n'
-    tmux.until { |lines| assert_includes lines, '>>1' }
-    tmux.send_keys 'C-n'
-    tmux.until { |lines| assert_includes lines, '>>4' }
-    tmux.send_keys 'C-p'
-    tmux.until { |lines| assert_includes lines, '>>1' }
-    tmux.send_keys 'C-p'
-    tmux.until { |lines| assert_includes lines, '>>2' }
-  end
-
-  def test_listen
-    { '--listen 6266' => -> { URI('http://localhost:6266') },
-      "--listen --sync --bind 'start:execute-silent:echo $FZF_PORT > /tmp/fzf-port'" =>
-        -> { URI("http://localhost:#{File.read('/tmp/fzf-port').chomp}") } }.each do |opts, fn|
-      tmux.send_keys "seq 10 | fzf #{opts}", :Enter
-      tmux.until { |lines| assert_equal 10, lines.item_count }
-      state = JSON.parse(Net::HTTP.get(fn.call), symbolize_names: true)
-      assert_equal 10, state[:totalCount]
-      assert_equal 10, state[:matchCount]
-      assert_empty state[:query]
-      assert_equal({ index: 0, text: '1' }, state[:current])
-
-      Net::HTTP.post(fn.call, 'change-query(yo)+reload(seq 100)+change-prompt:hundred> ')
-      tmux.until { |lines| assert_equal 100, lines.item_count }
-      tmux.until { |lines| assert_equal 'hundred> yo', lines[-1] }
-      state = JSON.parse(Net::HTTP.get(fn.call), symbolize_names: true)
-      assert_equal 100, state[:totalCount]
-      assert_equal 0, state[:matchCount]
-      assert_equal 'yo', state[:query]
-      assert_nil state[:current]
-
-      teardown
-      setup
-    end
-  end
-
-  def test_listen_with_api_key
-    post_uri = URI('http://localhost:6266')
-    tmux.send_keys 'seq 10 | FZF_API_KEY=123abc fzf --listen 6266', :Enter
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-    # Incorrect API Key
-    [nil, { 'x-api-key' => '' }, { 'x-api-key' => '124abc' }].each do |headers|
-      res = Net::HTTP.post(post_uri, 'change-query(yo)+reload(seq 100)+change-prompt:hundred> ', headers)
-      assert_equal '401', res.code
-      assert_equal 'Unauthorized', res.message
-      assert_equal "invalid api key\n", res.body
-    end
-    # Valid API Key
-    [{ 'x-api-key' => '123abc' }, { 'X-API-Key' => '123abc' }].each do |headers|
-      res = Net::HTTP.post(post_uri, 'change-query(yo)+reload(seq 100)+change-prompt:hundred> ', headers)
-      assert_equal '200', res.code
-      tmux.until { |lines| assert_equal 100, lines.item_count }
-      tmux.until { |lines| assert_equal 'hundred> yo', lines[-1] }
-    end
-  end
-
-  def test_toggle_alternative_preview_window
-    tmux.send_keys "seq 10 | #{FZF} --bind space:toggle-preview --preview-window '<100000(hidden,up,border-none)' --preview 'echo /{}/{}/'", :Enter
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-    tmux.until { |lines| refute_includes lines, '/1/1/' }
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_includes lines, '/1/1/' }
-  end
-
-  def test_alternative_preview_window_opts
-    tmux.send_keys "seq 10 | #{FZF} --preview-window '~5,2,+0,<100000(~0,+100,wrap,noinfo)' --preview 'seq 1000'", :Enter
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-    tmux.until do |lines|
-      assert_equal ['╭────╮', '│ 10 │', '│ 0  │', '│ 10 │', '│ 1  │'], lines.take(5).map(&:strip)
-    end
-  end
-
-  def test_preview_window_width_exception
-    tmux.send_keys "seq 10 | #{FZF} --scrollbar --preview-window border-left --border --preview 'seq 1000'", :Enter
-    tmux.until do |lines|
-      assert lines[1]&.end_with?(' 1/1000││')
-    end
-  end
-
-  def test_become
-    tmux.send_keys "seq 100 | #{FZF} --bind 'enter:become:seq {} | #{FZF}'", :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys 999
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal 99, lines.item_count }
-  end
-
-  def test_no_extra_newline_issue_3209
-    tmux.send_keys(%(seq 100 | #{FZF} --height 10 --preview-window up,wrap,border-rounded --preview 'printf "─%.0s" $(seq 1 "$((FZF_PREVIEW_COLUMNS - 5))"); printf $"\\e[7m%s\\e[0m" title; echo; echo something'), :Enter)
-    expected = <<~OUTPUT
-      ╭──────────
-      │ ─────────
-      │ something
-      │
-      ╰──────────
-        3
-        2
-      > 1
-        100/100 ─
-      >
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_track
-    tmux.send_keys "seq 1000 | #{FZF} --query 555 --track --bind t:toggle-track", :Enter
-    tmux.until do |lines|
-      assert_equal 1, lines.match_count
-      assert_includes lines, '> 555'
-    end
-    tmux.send_keys :BSpace
-    index = tmux.until do |lines|
-      assert_equal 28, lines.match_count
-      assert_includes lines, '> 555'
-    end.index('> 555')
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 271, lines.match_count
-      assert_equal '> 555', lines[index]
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 1000, lines.match_count
-      assert_equal '> 555', lines[index]
-    end
-    tmux.send_keys '555'
-    tmux.until do |lines|
-      assert_equal 1, lines.match_count
-      assert_includes lines, '> 555'
-      assert_includes lines[-2], '+T'
-    end
-    tmux.send_keys 't'
-    tmux.until do |lines|
-      refute_includes lines[-2], '+T'
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 28, lines.match_count
-      assert_includes lines, '> 55'
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 271, lines.match_count
-      assert_includes lines, '> 5'
-    end
-    tmux.send_keys 't'
-    tmux.until do |lines|
-      assert_includes lines[-2], '+T'
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 1000, lines.match_count
-      assert_includes lines, '> 5'
-    end
-  end
-
-  def test_track_action
-    tmux.send_keys "seq 1000 | #{FZF} --query 555 --bind t:track", :Enter
-    tmux.until do |lines|
-      assert_equal 1, lines.match_count
-      assert_includes lines, '> 555'
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 28, lines.match_count
-      assert_includes lines, '> 55'
-    end
-    tmux.send_keys :t
-    tmux.until do |lines|
-      assert_includes lines[-2], '+t'
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 271, lines.match_count
-      assert_includes lines, '> 55'
-    end
-
-    # Automatically disabled when the tracking item is no longer visible
-    tmux.send_keys '4'
-    tmux.until do |lines|
-      assert_equal 28, lines.match_count
-      refute_includes lines[-2], '+t'
-    end
-    tmux.send_keys :BSpace
-    tmux.until do |lines|
-      assert_equal 271, lines.match_count
-      assert_includes lines, '> 5'
-    end
-    tmux.send_keys :t
-    tmux.until do |lines|
-      assert_includes lines[-2], '+t'
-    end
-    tmux.send_keys :Up
-    tmux.until do |lines|
-      refute_includes lines[-2], '+t'
-    end
-  end
-
-  def test_one_and_zero
-    tmux.send_keys "seq 10 | #{FZF} --bind 'zero:preview(echo no match),one:preview(echo {} is the only match)'", :Enter
-    tmux.send_keys '1'
-    tmux.until do |lines|
-      assert_equal 2, lines.match_count
-      refute(lines.any? { _1.include?('only match') })
-      refute(lines.any? { _1.include?('no match') })
-    end
-    tmux.send_keys '0'
-    tmux.until do |lines|
-      assert_equal 1, lines.match_count
-      assert(lines.any? { _1.include?('only match') })
-    end
-    tmux.send_keys '0'
-    tmux.until do |lines|
-      assert_equal 0, lines.match_count
-      assert(lines.any? { _1.include?('no match') })
-    end
-  end
-
-  def test_height_range_with_exit_0
-    tmux.send_keys "seq 10 | #{FZF} --height ~10% --exit-0", :Enter
-    tmux.until { |lines| assert_equal 10, lines.item_count }
-    tmux.send_keys :c
-    tmux.until { |lines| assert_equal 0, lines.match_count }
-  end
-
-  def test_reload_and_change
-    tmux.send_keys "(echo foo; echo bar) | #{FZF} --bind 'load:reload-sync(sleep 60)+change-query(bar)'", :Enter
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-  end
-
-  def test_reload_and_change_cache
-    tmux.send_keys "echo bar | #{FZF} --bind 'zero:change-header(foo)+reload(echo foo)+clear-query'", :Enter
-    expected = <<~OUTPUT
-      > bar
-        1/1
-      >
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-    tmux.send_keys :z
-    expected = <<~OUTPUT
-      > foo
-        foo
-        1/1
-      >
-    OUTPUT
-    tmux.until { assert_block(expected, _1) }
-  end
-
-  def test_delete_with_modifiers
-    if ENV['GITHUB_ACTION']
-      # Expected: "[3]"
-      # Actual: "[]3;5~"
-      skip('CTRL-DELETE is not properly handled in GitHub Actions environment')
-    end
-    tmux.send_keys "seq 100 | #{FZF} --bind 'ctrl-delete:up+up,shift-delete:down,focus:transform-prompt:echo [{}]'", :Enter
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys 'C-Delete'
-    tmux.until { |lines| assert_equal '[3]', lines[-1] }
-    tmux.send_keys 'S-Delete'
-    tmux.until { |lines| assert_equal '[2]', lines[-1] }
-  end
-
-  def test_become_tty
-    tmux.send_keys "sleep 0.5 | #{FZF} --bind 'start:reload:ls' --bind 'load:become:tty'", :Enter
-    tmux.until { |lines| assert_includes lines, '/dev/tty' }
-  end
-
-  def test_disabled_preview_update
-    tmux.send_keys "echo bar | #{FZF} --disabled --bind 'change:reload:echo foo' --preview 'echo [{q}-{}]'", :Enter
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.until { |lines| assert(lines.any? { |line| line.include?('[-bar]') }) }
-    tmux.send_keys :x
-    tmux.until { |lines| assert(lines.any? { |line| line.include?('[x-foo]') }) }
-  end
-
-  def test_preview_window_hidden_on_focus
-    tmux.send_keys "seq 3 | #{FZF} --preview 'echo {}' --bind focus:hide-preview", :Enter
-    tmux.until { |lines| assert_includes lines, '> 1' }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert_includes lines, '> 2' }
-  end
-
-  def test_fzf_pos
-    tmux.send_keys "seq 100 | #{FZF} --preview 'echo $FZF_POS / $FZF_MATCH_COUNT'", :Enter
-    tmux.until { |lines| assert(lines.any? { |line| line.include?('1 / 100') }) }
-    tmux.send_keys :Up
-    tmux.until { |lines| assert(lines.any? { |line| line.include?('2 / 100') }) }
-    tmux.send_keys '99'
-    tmux.until { |lines| assert(lines.any? { |line| line.include?('1 / 1') }) }
-    tmux.send_keys '99'
-    tmux.until { |lines| assert(lines.any? { |line| line.include?('0 / 0') }) }
-  end
-
-  def test_fzf_multi_line
-    tmux.send_keys %[(echo -en '0\\0'; echo -en '1\\n2\\0'; seq 1000) | fzf --read0 --multi --bind load:select-all --border rounded], :Enter
-    block = <<~BLOCK
-      │  ┃998
-      │  ┃999
-      │  ┃1000
-      │  ╹
-      │  ╻1
-      │  ╹2
-      │ >>0
-      │   3/3 (3)
-      │ >
-      ╰───────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-    tmux.send_keys :Up, :Up
-    block = <<~BLOCK
-      ╭───────
-      │ >╻1
-      │ >┃2
-      │ >┃3
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-
-    block = <<~BLOCK
-      │ >┃
-      │
-      │ >
-      ╰───
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_fzf_multi_line_reverse
-    tmux.send_keys %[(echo -en '0\\0'; echo -en '1\\n2\\0'; seq 1000) | fzf --read0 --multi --bind load:select-all --border rounded --reverse], :Enter
-    block = <<~BLOCK
-      ╭───────────
-      │ >
-      │   3/3 (3)
-      │ >>0
-      │  ╻1
-      │  ╹2
-      │  ╻1
-      │  ┃2
-      │  ┃3
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_fzf_multi_line_no_pointer_and_marker
-    tmux.send_keys %[(echo -en '0\\0'; echo -en '1\\n2\\0'; seq 1000) | fzf --read0 --multi --bind load:select-all --border rounded --reverse --pointer '' --marker '' --marker-multi-line ''], :Enter
-    block = <<~BLOCK
-      ╭───────────
-      │ >
-      │   3/3 (3)
-      │ 0
-      │ 1
-      │ 2
-      │ 1
-      │ 2
-      │ 3
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_start_on_reload
-    tmux.send_keys %(echo foo | #{FZF} --header Loading --header-lines 1 --bind 'start:reload:sleep 2; echo bar' --bind 'load:change-header:Loaded' --bind space:change-header:), :Enter
-    tmux.until(timeout: 1) { |lines| assert_includes lines[-3], 'Loading' }
-    tmux.until(timeout: 1) { |lines| refute_includes lines[-4], 'foo' }
-    tmux.until { |lines| assert_includes lines[-3], 'Loaded' }
-    tmux.until { |lines| assert_includes lines[-4], 'bar' }
-    tmux.send_keys :Space
-    tmux.until { |lines| assert_includes lines[-3], 'bar' }
-  end
-
-  def test_boundary_match
-    # Underscore boundaries should be ranked lower
-    {
-      default: [' x '] + %w[/x/ [x] -x- -x_ _x- _x_],
-      path: ['/x/', ' x '] + %w[[x] -x- -x_ _x- _x_],
-      history: ['[x]', '-x-', ' x '] + %w[/x/ -x_ _x- _x_]
-    }.each do |scheme, expected|
-      result = `printf -- 'xxx\n-xx\nxx-\n_x_\n_x-\n-x_\n[x]\n-x-\n x \n/x/\n' | #{FZF} -f"'x'" --scheme=#{scheme}`.lines(chomp: true)
-      assert_equal expected, result
-    end
-  end
-
-  def test_preview_window_noinfo
-    # │ 1        ││
-    tmux.send_keys %(#{FZF} --preview 'seq 1000' --preview-window top,noinfo --scrollbar --bind space:change-preview-window:info), :Enter
-    tmux.until do |lines|
-      assert lines[1]&.start_with?('│ 1')
-      assert lines[1]&.end_with?('  ││')
-    end
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert lines[1]&.start_with?('│ 1')
-      assert lines[1]&.end_with?('1000││')
-    end
-  end
-
-  def test_gap
-    tmux.send_keys %(seq 100 | #{FZF} --gap --border --reverse), :Enter
-    block = <<~BLOCK
-      ╭─────────────────
-      │ >
-      │   100/100 ──────
-      │ > 1
-      │   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈
-      │   2
-      │   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈
-      │   3
-      │   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈
-      │   4
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_gap_2
-    tmux.send_keys %(seq 100 | #{FZF} --gap=2 --gap-line xyz --border --reverse), :Enter
-    block = <<~BLOCK
-      ╭─────────────────
-      │ >
-      │   100/100 ──────
-      │ > 1
-      │
-      │   xyzxyzxyzxyzxy
-      │   2
-      │
-      │   xyzxyzxyzxyzxy
-      │   3
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_list_border_and_label
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --query 1 --padding 1,2), :Enter
-    block = <<~BLOCK
-      │   ║   11
-      │   ║ > 10
-      │   ║   3
-      │   ║   2
-      │   ║   1
-      │   ║   19/97 ─
-      │   ║ > 1
-      │   ╚list══════
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_input_border_and_label
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --input-border bold --input-label input --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2), :Enter
-    block = <<~BLOCK
-      │     11
-      │   > 10
-      │     3
-      │     2
-      │     1
-      │   ┏input━━━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗━━━━━━━━━━
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_input_border_and_label_header_first
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --input-border bold --input-label input --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2 --header-first), :Enter
-    block = <<~BLOCK
-      │     11
-      │   > 10
-      │   ┏input━━━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗━━━━━━━━━━
-      │     3
-      │     2
-      │     1
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_list_input_border_and_label
-    tmux.send_keys %(
-      seq 100 | #{FZF} --border rounded --list-border double --input-border bold --list-label-pos 2:bottom --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2 \
-      --bind 'start:transform-input-label(echo INPUT)+transform-list-label(echo LIST)' \
-      --bind 'space:change-input-label( input )+change-list-label( list )'
-    ).strip, :Enter
-    block = <<~BLOCK
-      │   ║   11
-      │   ║ > 10
-      │   ╚LIST══════
-      │       3
-      │       2
-      │       1
-      │   ┏INPUT━━━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗━━━━━━━━━━
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-    tmux.send_keys :Space
-    block = <<~BLOCK
-      │   ║   11
-      │   ║ > 10
-      │   ╚ list ════
-      │       3
-      │       2
-      │       1
-      │   ┏ input ━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗━━━━━━━━━━
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_list_input_border_and_label_header_first
-    tmux.send_keys %(
-      seq 100 | #{FZF} --border rounded --list-border double --input-border bold --list-label-pos 2:bottom --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2 \
-      --bind 'start:transform-input-label(echo INPUT)+transform-list-label(echo LIST)' \
-      --bind 'space:change-input-label( input )+change-list-label( list )' --header-first
-    ).strip, :Enter
-    block = <<~BLOCK
-      │   ║   11
-      │   ║ > 10
-      │   ╚LIST══════
-      │   ┏INPUT━━━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗━━━━━━━━━━
-      │       3
-      │       2
-      │       1
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-    tmux.send_keys :Space
-    block = <<~BLOCK
-      │   ║   11
-      │   ║ > 10
-      │   ╚ list ════
-      │   ┏ input ━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗━━━━━━━━━━
-      │       3
-      │       2
-      │       1
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_header_border_and_label
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2), :Enter
-    block = <<~BLOCK
-      │     12
-      │     11
-      │   > 10
-      │   ┌────────
-      │   │ 3
-      │   │ 2
-      │   │ 1
-      │   └header──
-      │     19/97 ─
-      │   > 1
-      │
-      ╰────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_header_border_toggle
-    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()'), :Enter
-    block1 = <<~BLOCK
-      │   5
-      │   4
-      │   3
-      │   2
-      │ > 1
-      │   100/100 ─
-      │ >
-      ╰────────────
-    BLOCK
-    tmux.until { assert_block(block1, _1) }
-
-    tmux.send_keys :Space
-    block2 = <<~BLOCK
-      │   3
-      │   2
-      │ > 1
-      ╰────────────
-      ╭────────────
-      │   hello
-      ╰────────────
-          100/100 ─
-        >
-    BLOCK
-    tmux.until { assert_block(block2, _1) }
-
-    tmux.send_keys :Enter
-    tmux.until { assert_block(block1, _1) }
-  end
-
-  def test_header_border_toggle_with_header_lines
-    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2), :Enter
-    block1 = <<~BLOCK
-      │   5
-      │   4
-      │ > 3
-      ╰──────────
-      ╭──────────
-      │   2
-      │   1
-      ╰──────────
-          98/98 ─
-        >
-    BLOCK
-    tmux.until { assert_block(block1, _1) }
-
-    tmux.send_keys :Space
-    block2 = <<~BLOCK
-      │   4
-      │ > 3
-      ╰──────────
-      ╭──────────
-      │   2
-      │   1
-      │   hello
-      ╰──────────
-          98/98 ─
-        >
-    BLOCK
-    tmux.until { assert_block(block2, _1) }
-
-    tmux.send_keys :Enter
-    tmux.until { assert_block(block1, _1) }
-  end
-
-  def test_header_border_toggle_with_header_lines_header_first
-    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2 --header-first), :Enter
-    block1 = <<~BLOCK
-      │   5
-      │   4
-      │ > 3
-      ╰──────────
-          98/98 ─
-        >
-      ╭──────────
-      │   2
-      │   1
-      ╰──────────
-    BLOCK
-    tmux.until { assert_block(block1, _1) }
-
-    tmux.send_keys :Space
-    block2 = <<~BLOCK
-      │   4
-      │ > 3
-      ╰──────────
-          98/98 ─
-        >
-      ╭──────────
-      │   2
-      │   1
-      │   hello
-      ╰──────────
-    BLOCK
-    tmux.until { assert_block(block2, _1) }
-
-    tmux.send_keys :Enter
-    tmux.until { assert_block(block1, _1) }
-  end
-
-  def test_header_border_toggle_with_header_lines_header_lines_border
-    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2 --header-lines-border double), :Enter
-    block1 = <<~BLOCK
-      │   5
-      │   4
-      │ > 3
-      ╰──────────
-      ╔══════════
-      ║   2
-      ║   1
-      ╚══════════
-          98/98 ─
-        >
-    BLOCK
-    tmux.until { assert_block(block1, _1) }
-
-    tmux.send_keys :Space
-    block2 = <<~BLOCK
-      │ > 3
-      ╰──────────
-      ╔══════════
-      ║   2
-      ║   1
-      ╚══════════
-      ╭──────────
-      │   hello
-      ╰──────────
-          98/98 ─
-        >
-    BLOCK
-    tmux.until { assert_block(block2, _1) }
-
-    tmux.send_keys :Enter
-    tmux.until { assert_block(block1, _1) }
-  end
-
-  def test_header_border_toggle_with_header_lines_header_first_header_lines_border
-    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2 --header-first --header-lines-border double), :Enter
-    block1 = <<~BLOCK
-      │   5
-      │   4
-      │ > 3
-      ╰──────────
-      ╔══════════
-      ║   2
-      ║   1
-      ╚══════════
-          98/98 ─
-        >
-    BLOCK
-    tmux.until { assert_block(block1, _1) }
-
-    tmux.send_keys :Space
-    block2 = <<~BLOCK
-      │ > 3
-      ╰──────────
-      ╔══════════
-      ║   2
-      ║   1
-      ╚══════════
-          98/98 ─
-        >
-      ╭──────────
-      │   hello
-      ╰──────────
-    BLOCK
-    tmux.until { assert_block(block2, _1) }
-
-    tmux.send_keys :Enter
-    tmux.until { assert_block(block1, _1) }
-  end
-
-  def test_header_border_and_label_header_first
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --header-first), :Enter
-    block = <<~BLOCK
-      │     12
-      │     11
-      │   > 10
-      │     19/97 ─
-      │   > 1
-      │   ┌────────
-      │   │ 3
-      │   │ 2
-      │   │ 1
-      │   └header──
-      │
-      ╰────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_header_border_and_label_with_list_border
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2), :Enter
-    block = <<~BLOCK
-      │   ║   12
-      │   ║   11
-      │   ║ > 10
-      │   ╚list══════
-      │   ┌──────────
-      │   │   3
-      │   │   2
-      │   │   1
-      │   └header────
-      │       19/97 ─
-      │     > 1
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_header_border_and_label_with_list_border_header_first
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --header-first), :Enter
-    block = <<~BLOCK
-      │   ║   12
-      │   ║   11
-      │   ║ > 10
-      │   ╚list══════
-      │       19/97 ─
-      │     > 1
-      │   ┌──────────
-      │   │   3
-      │   │   2
-      │   │   1
-      │   └header────
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_all_borders
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --input-border bold --input-label input --input-label-pos 2:bottom), :Enter
-    block = <<~BLOCK
-      │   ║   12
-      │   ║   11
-      │   ║ > 10
-      │   ╚list══════
-      │   ┌──────────
-      │   │   3
-      │   │   2
-      │   │   1
-      │   └header────
-      │   ┏━━━━━━━━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗input━━━━━
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_all_borders_header_first
-    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --input-border bold --input-label input --input-label-pos 2:bottom --header-first), :Enter
-    block = <<~BLOCK
-      │   ║   12
-      │   ║   11
-      │   ║ > 10
-      │   ╚list══════
-      │   ┏━━━━━━━━━━
-      │   ┃   19/97
-      │   ┃ > 1
-      │   ┗input━━━━━
-      │   ┌──────────
-      │   │   3
-      │   │   2
-      │   │   1
-      │   └header────
-      │
-      ╰──────────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_style_full_adaptive_height
-    tmux.send_keys %(seq 1| #{FZF} --style=full --height=~100% --header-lines=1 --info=default), :Enter
-    block = <<~BLOCK
-      ╭────────
-      ╰────────
-      ╭────────
-      │   1
-      ╰────────
-      ╭────────
-      │   0/0
-      │ >
-      ╰────────
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_style_full_adaptive_height_double
-    tmux.send_keys %(seq 1| #{FZF} --style=full:double --border --height=~100% --header-lines=1 --info=default), :Enter
-    block = <<~BLOCK
-      ╔══════════
-      ║ ╔════════
-      ║ ╚════════
-      ║ ╔════════
-      ║ ║   1
-      ║ ╚════════
-      ║ ╔════════
-      ║ ║   0/0
-      ║ ║ >
-      ║ ╚════════
-      ╚══════════
-    BLOCK
-    tmux.until { assert_block(block, _1) }
-  end
-
-  def test_change_nth
-    input = [
-      *[''] * 1000,
-      'foo bar bar bar bar',
-      'foo foo bar bar bar',
-      'foo foo foo bar bar',
-      'foo foo foo foo bar',
-      *[''] * 1000
-    ]
-    writelines(input)
-    nths = '1,2..4,-1,-3..,..2'
-    tmux.send_keys %(#{FZF} -qfoo -n#{nths} --bind 'space:change-nth(2|3|4|5|),result:transform-prompt:echo "[$FZF_NTH] "' < #{tempname}), :Enter
-
-    tmux.until do |lines|
-      assert lines.any_include?("[#{nths}] foo")
-      assert_equal 4, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert lines.any_include?('[2] foo')
-      assert_equal 3, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert lines.any_include?('[3] foo')
-      assert_equal 2, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert lines.any_include?('[4] foo')
-      assert_equal 1, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert lines.any_include?('[5] foo')
-      assert_equal 0, lines.match_count
-    end
-    tmux.send_keys :Space
-    tmux.until do |lines|
-      assert lines.any_include?("[#{nths}] foo")
-      assert_equal 4, lines.match_count
-    end
-  end
-end
-
-module TestShell
-  def setup
-    @tmux = Tmux.new(shell)
-    tmux.prepare
-  end
-
-  def teardown
-    @tmux.kill
-  end
-
-  def set_var(name, val)
-    tmux.prepare
-    tmux.send_keys "export #{name}='#{val}'", :Enter
-    tmux.prepare
-  end
-
-  def unset_var(name)
-    tmux.prepare
-    tmux.send_keys "unset #{name}", :Enter
-    tmux.prepare
-  end
-
-  def test_ctrl_t
-    set_var('FZF_CTRL_T_COMMAND', 'seq 100')
-
-    tmux.prepare
-    tmux.send_keys 'C-t'
-    tmux.until { |lines| assert_equal 100, lines.item_count }
-    tmux.send_keys :Tab, :Tab, :Tab
-    tmux.until { |lines| assert lines.any_include?(' (3)') }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert lines.any_include?('1 2 3') }
-    tmux.send_keys 'C-c'
-  end
-
-  def test_ctrl_t_unicode
-    writelines(['fzf-unicode 테스트1', 'fzf-unicode 테스트2'])
-    set_var('FZF_CTRL_T_COMMAND', "cat #{tempname}")
-
-    tmux.prepare
-    tmux.send_keys 'echo ', 'C-t'
-    tmux.until { |lines| assert_equal 2, lines.item_count }
-    tmux.send_keys 'fzf-unicode'
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-
-    tmux.send_keys '1'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal 1, lines.select_count }
-
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-
-    tmux.send_keys '2'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal 2, lines.select_count }
-
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_match(/echo .*fzf-unicode.*1.* .*fzf-unicode.*2/, lines.join) }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal 'fzf-unicode 테스트1 fzf-unicode 테스트2', lines[-1] }
-  end
-
-  def test_alt_c
-    tmux.prepare
-    tmux.send_keys :Escape, :c
-    lines = tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    expected = lines.reverse.find { |l| l.start_with?('> ') }[2..]
-    tmux.send_keys :Enter
-    tmux.prepare
-    tmux.send_keys :pwd, :Enter
-    tmux.until { |lines| assert lines[-1]&.end_with?(expected) }
-  end
-
-  def test_alt_c_command
-    set_var('FZF_ALT_C_COMMAND', 'echo /tmp')
-
-    tmux.prepare
-    tmux.send_keys 'cd /', :Enter
-
-    tmux.prepare
-    tmux.send_keys :Escape, :c
-    tmux.until { |lines| assert_equal 1, lines.item_count }
-    tmux.send_keys :Enter
-
-    tmux.prepare
-    tmux.send_keys :pwd, :Enter
-    tmux.until { |lines| assert_equal '/tmp', lines[-1] }
-  end
-
-  def test_ctrl_r
-    tmux.prepare
-    tmux.send_keys 'echo 1st', :Enter
-    tmux.prepare
-    tmux.send_keys 'echo 2nd', :Enter
-    tmux.prepare
-    tmux.send_keys 'echo 3d', :Enter
-    tmux.prepare
-    3.times do
-      tmux.send_keys 'echo 3rd', :Enter
-      tmux.prepare
-    end
-    tmux.send_keys 'echo 4th', :Enter
-    tmux.prepare
-    tmux.send_keys 'C-r'
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys 'e3d'
-    # Duplicates removed: 3d (1) + 3rd (1) => 2 matches
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-    tmux.until { |lines| assert lines[-3]&.end_with?(' echo 3d') }
-    tmux.send_keys 'C-r'
-    tmux.until { |lines| assert lines[-3]&.end_with?(' echo 3rd') }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal 'echo 3rd', lines[-1] }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal '3rd', lines[-1] }
-  end
-
-  def test_ctrl_r_multiline
-    # NOTE: Current bash implementation shows an extra new line if there's
-    # only entry in the history
-    tmux.send_keys ':', :Enter
-    tmux.send_keys 'echo "foo', :Enter, 'bar"', :Enter
-    tmux.until { |lines| assert_equal %w[foo bar], lines[-2..] }
-    tmux.prepare
-    tmux.send_keys 'C-r'
-    tmux.until { |lines| assert_equal '>', lines[-1] }
-    tmux.send_keys 'foo bar'
-    tmux.until { |lines| assert lines[-4]&.match?(/"foo/) } unless shell == :zsh
-    tmux.until { |lines| assert lines[-3]&.match?(/bar"␊?/) }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert lines[-1]&.match?(/bar"␊?/) }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal %w[foo bar], lines[-2..] }
-  end
-
-  def test_ctrl_r_abort
-    skip("doesn't restore the original line when search is aborted pre Bash 4") if shell == :bash && `#{Shell.bash} --version`[/(?<= version )\d+/].to_i < 4
-    %w[foo ' "].each do |query|
-      tmux.prepare
-      tmux.send_keys :Enter, query
-      tmux.until { |lines| assert lines[-1]&.start_with?(query) }
-      tmux.send_keys 'C-r'
-      tmux.until { |lines| assert_equal "> #{query}", lines[-1] }
-      tmux.send_keys 'C-g'
-      tmux.until { |lines| assert lines[-1]&.start_with?(query) }
-    end
-  end
-end
-
-module CompletionTest
-  def test_file_completion
-    FileUtils.mkdir_p('/tmp/fzf-test')
-    FileUtils.mkdir_p('/tmp/fzf test')
-    (1..100).each { |i| FileUtils.touch("/tmp/fzf-test/#{i}") }
-    ['no~such~user', '/tmp/fzf test/foobar'].each do |f|
-      FileUtils.touch(File.expand_path(f))
-    end
-    tmux.prepare
-    tmux.send_keys 'cat /tmp/fzf-test/10**', :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys ' !d'
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-    tmux.send_keys :Tab, :Tab
-    tmux.until { |lines| assert_equal 2, lines.select_count }
-    tmux.send_keys :Enter
-    tmux.until(true) do |lines|
-      assert_equal 'cat /tmp/fzf-test/10 /tmp/fzf-test/100', lines[-1]
-    end
-
-    # ~USERNAME**<TAB>
-    user = `whoami`.chomp
-    tmux.send_keys 'C-u'
-    tmux.send_keys "cat ~#{user}**", :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys "/#{user}"
-    tmux.until { |lines| assert(lines.any? { |l| l.end_with?("/#{user}") }) }
-    tmux.send_keys :Enter
-    tmux.until(true) do |lines|
-      assert_match %r{cat .*/#{user}}, lines[-1]
-    end
-
-    # ~INVALID_USERNAME**<TAB>
-    tmux.send_keys 'C-u'
-    tmux.send_keys 'cat ~such**', :Tab
-    tmux.until(true) { |lines| assert lines.any_include?('no~such~user') }
-    tmux.send_keys :Enter
-    tmux.until(true) { |lines| assert_equal 'cat no~such~user', lines[-1] }
-
-    # /tmp/fzf\ test**<TAB>
-    tmux.send_keys 'C-u'
-    tmux.send_keys 'cat /tmp/fzf\ test/**', :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys 'foobar$'
-    tmux.until do |lines|
-      assert_equal 1, lines.match_count
-      assert lines.any_include?('> /tmp/fzf test/foobar')
-    end
-    tmux.send_keys :Enter
-    tmux.until(true) { |lines| assert_equal 'cat /tmp/fzf\ test/foobar', lines[-1] }
-
-    # Should include hidden files
-    (1..100).each { |i| FileUtils.touch("/tmp/fzf-test/.hidden-#{i}") }
-    tmux.send_keys 'C-u'
-    tmux.send_keys 'cat /tmp/fzf-test/hidden**', :Tab
-    tmux.until(true) do |lines|
-      assert_equal 100, lines.match_count
-      assert lines.any_include?('/tmp/fzf-test/.hidden-')
-    end
-    tmux.send_keys :Enter
-  ensure
-    ['/tmp/fzf-test', '/tmp/fzf test', '~/.fzf-home', 'no~such~user'].each do |f|
-      FileUtils.rm_rf(File.expand_path(f))
-    end
-  end
-
-  def test_file_completion_root
-    tmux.send_keys 'ls /**', :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys :Enter
-  end
-
-  def test_dir_completion
-    (1..100).each do |idx|
-      FileUtils.mkdir_p("/tmp/fzf-test/d#{idx}")
-    end
-    FileUtils.touch('/tmp/fzf-test/d55/xxx')
-    tmux.prepare
-    tmux.send_keys 'cd /tmp/fzf-test/**', :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys :Tab, :Tab # Tab does not work here
-    tmux.send_keys 55
-    tmux.until do |lines|
-      assert_equal 1, lines.match_count
-      assert_includes lines, '> 55'
-      assert_includes lines, '> /tmp/fzf-test/d55'
-    end
-    tmux.send_keys :Enter
-    tmux.until(true) { |lines| assert_equal 'cd /tmp/fzf-test/d55/', lines[-1] }
-    tmux.send_keys :xx
-    tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55/xx', lines[-1] }
-
-    # Should not match regular files (bash-only)
-    if instance_of?(TestBash)
-      tmux.send_keys :Tab
-      tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55/xx', lines[-1] }
-    end
-
-    # Fail back to plusdirs
-    tmux.send_keys :BSpace, :BSpace, :BSpace
-    tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55', lines[-1] }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55/', lines[-1] }
-  end
-
-  def test_process_completion
-    tmux.send_keys 'sleep 12345 &', :Enter
-    lines = tmux.until { |lines| assert lines[-1]&.start_with?('[1] ') }
-    pid = lines[-1]&.split&.last
-    tmux.prepare
-    tmux.send_keys 'C-L'
-    tmux.send_keys 'kill **', :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys 'sleep12345'
-    tmux.until { |lines| assert lines.any_include?('sleep 12345') }
-    tmux.send_keys :Enter
-    tmux.until(true) { |lines| assert_equal "kill #{pid}", lines[-1] }
-  ensure
-    if pid
-      begin
-        Process.kill('KILL', pid.to_i)
-      rescue StandardError
-        nil
-      end
-    end
-  end
-
-  def test_custom_completion
-    tmux.send_keys '_fzf_compgen_path() { echo "$1"; seq 10; }', :Enter
-    tmux.prepare
-    tmux.send_keys 'ls /tmp/**', :Tab
-    tmux.until { |lines| assert_equal 11, lines.match_count }
-    tmux.send_keys :Tab, :Tab, :Tab
-    tmux.until { |lines| assert_equal 3, lines.select_count }
-    tmux.send_keys :Enter
-    tmux.until(true) { |lines| assert_equal 'ls /tmp 1 2', lines[-1] }
-  end
-
-  def test_unset_completion
-    tmux.send_keys 'export FZFFOOBAR=BAZ', :Enter
-    tmux.prepare
-
-    # Using tmux
-    tmux.send_keys 'unset FZFFOOBR**', :Tab
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal 'unset FZFFOOBAR', lines[-1] }
-    tmux.send_keys 'C-c'
-
-    # FZF_TMUX=1
-    new_shell
-    tmux.focus
-    tmux.send_keys 'unset FZFFOOBR**', :Tab
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal 'unset FZFFOOBAR', lines[-1] }
-  end
-
-  def test_completion_in_command_sequence
-    tmux.send_keys 'export FZFFOOBAR=BAZ', :Enter
-    tmux.prepare
-
-    triggers = ['**', '~~', '++', 'ff', '/']
-    triggers.concat(['&', '[', ';', '`']) if instance_of?(TestZsh)
-
-    triggers.each do |trigger|
-      set_var('FZF_COMPLETION_TRIGGER', trigger)
-      command = "echo foo; QUX=THUD unset FZFFOOBR#{trigger}"
-      tmux.send_keys command.sub(/(;|`)$/, '\\\\\1'), :Tab
-      tmux.until { |lines| assert_equal 1, lines.match_count }
-      tmux.send_keys :Enter
-      tmux.until { |lines| assert_equal 'echo foo; QUX=THUD unset FZFFOOBAR', lines[-1] }
-    end
-  end
-
-  def test_file_completion_unicode
-    FileUtils.mkdir_p('/tmp/fzf-test')
-    tmux.paste "cd /tmp/fzf-test; echo test3 > $'fzf-unicode \\355\\205\\214\\354\\212\\244\\355\\212\\2701'; echo test4 > $'fzf-unicode \\355\\205\\214\\354\\212\\244\\355\\212\\2702'"
-    tmux.prepare
-    tmux.send_keys 'cat fzf-unicode**', :Tab
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-
-    tmux.send_keys '1'
-    tmux.until { |lines| assert_equal 1, lines.match_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal 1, lines.select_count }
-
-    tmux.send_keys :BSpace
-    tmux.until { |lines| assert_equal 2, lines.match_count }
-
-    tmux.send_keys '2'
-    tmux.until { |lines| assert_equal 1, lines.select_count }
-    tmux.send_keys :Tab
-    tmux.until { |lines| assert_equal 2, lines.select_count }
-
-    tmux.send_keys :Enter
-    tmux.until(true) { |lines| assert_match(/cat .*fzf-unicode.*1.* .*fzf-unicode.*2/, lines[-1]) }
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert_equal %w[test3 test4], lines[-2..] }
-  end
-
-  def test_custom_completion_api
-    tmux.send_keys 'eval "_fzf$(declare -f _comprun)"', :Enter
-    %w[f g].each do |command|
-      tmux.prepare
-      tmux.send_keys "#{command} b**", :Tab
-      tmux.until do |lines|
-        assert_equal 2, lines.item_count
-        assert_equal 1, lines.match_count
-        assert lines.any_include?("prompt-#{command}")
-        assert lines.any_include?("preview-#{command}-bar")
-      end
-      tmux.send_keys :Enter
-      tmux.until { |lines| assert_equal "#{command} #{command}barbar", lines[-1] }
-      tmux.send_keys 'C-u'
-    end
-  ensure
-    tmux.prepare
-    tmux.send_keys 'unset -f _fzf_comprun', :Enter
-  end
-
-  def test_ssh_completion
-    (1..5).each { |i| FileUtils.touch("/tmp/fzf-test-ssh-#{i}") }
-
-    tmux.send_keys 'ssh jg@localhost**', :Tab
-    tmux.until do |lines|
-      assert lines.match_count >= 1
-    end
-
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert lines.any_include?('ssh jg@localhost') }
-    tmux.send_keys ' -i /tmp/fzf-test-ssh**', :Tab
-    tmux.until do |lines|
-      assert lines.match_count >= 5
-      assert_equal 0, lines.select_count
-    end
-    tmux.send_keys :Tab, :Tab, :Tab
-    tmux.until do |lines|
-      assert_equal 3, lines.select_count
-    end
-    tmux.send_keys :Enter
-    tmux.until { |lines| assert lines.any_include?('ssh jg@localhost  -i /tmp/fzf-test-ssh-') }
-
-    tmux.send_keys 'localhost**', :Tab
-    tmux.until do |lines|
-      assert lines.match_count >= 1
-    end
-  end
-end
-
-class TestBash < TestBase
-  include TestShell
-  include CompletionTest
-
-  def shell
-    :bash
-  end
-
-  def new_shell
-    tmux.prepare
-    tmux.send_keys "FZF_TMUX=1 #{Shell.bash}", :Enter
-    tmux.prepare
-  end
-
-  def test_dynamic_completion_loader
-    tmux.paste 'touch /tmp/foo; _fzf_completion_loader=1'
-    tmux.paste '_completion_loader() { complete -o default fake; }'
-    tmux.paste 'complete -F _fzf_path_completion -o default -o bashdefault fake'
-    tmux.send_keys 'fake /tmp/foo**', :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-    tmux.send_keys 'C-c'
-
-    tmux.prepare
-    tmux.send_keys 'fake /tmp/foo'
-    tmux.send_keys :Tab, 'C-u'
-
-    tmux.prepare
-    tmux.send_keys 'fake /tmp/foo**', :Tab
-    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
-  end
-end
-
-class TestZsh < TestBase
-  include TestShell
-  include CompletionTest
-
-  def shell
-    :zsh
-  end
-
-  def new_shell
-    tmux.send_keys "FZF_TMUX=1 #{Shell.zsh}", :Enter
-    tmux.prepare
-  end
-
-  def test_complete_quoted_command
-    tmux.send_keys 'export FZFFOOBAR=BAZ', :Enter
-    ['unset', '\unset', "'unset'"].each do |command|
-      tmux.prepare
-      tmux.send_keys "#{command} FZFFOOBR**", :Tab
-      tmux.until { |lines| assert_equal 1, lines.match_count }
-      tmux.send_keys :Enter
-      tmux.until { |lines| assert_equal "#{command} FZFFOOBAR", lines[-1] }
-      tmux.send_keys 'C-c'
-    end
-  end
-end
-
-class TestFish < TestBase
-  include TestShell
-
-  def shell
-    :fish
-  end
-
-  def new_shell
-    tmux.send_keys 'env FZF_TMUX=1 FZF_DEFAULT_OPTS=--no-scrollbar fish', :Enter
-    tmux.send_keys 'function fish_prompt; end; clear', :Enter
-    tmux.until { |lines| assert_empty lines }
-  end
-
-  def set_var(name, val)
-    tmux.prepare
-    tmux.send_keys "set -g #{name} '#{val}'", :Enter
-    tmux.prepare
-  end
-end
-
-__END__
-set -u
-PS1= PROMPT_COMMAND= HISTFILE= HISTSIZE=100
-unset <%= UNSETS.join(' ') %>
-unset $(env | sed -n /^_fzf_orig/s/=.*//p)
-unset $(declare -F | sed -n "/_fzf/s/.*-f //p")
-
-export FZF_DEFAULT_OPTS="--no-scrollbar --pointer '>' --marker '>'"
-
-# Setup fzf
-# ---------
-if [[ ! "$PATH" == *<%= BASE %>/bin* ]]; then
-  export PATH="${PATH:+${PATH}:}<%= BASE %>/bin"
-fi
-
-# Auto-completion
-# ---------------
-[[ $- == *i* ]] && source "<%= BASE %>/shell/completion.<%= __method__ %>" 2> /dev/null
-
-# Key bindings
-# ------------
-source "<%= BASE %>/shell/key-bindings.<%= __method__ %>"
-
-# Old API
-_fzf_complete_f() {
-  _fzf_complete "+m --multi --prompt \"prompt-f> \"" "$@" < <(
-    echo foo
-    echo bar
-  )
-}
-
-# New API
-_fzf_complete_g() {
-  _fzf_complete +m --multi --prompt "prompt-g> " -- "$@" < <(
-    echo foo
-    echo bar
-  )
-}
-
-_fzf_complete_f_post() {
-  awk '{print "f" $0 $0}'
-}
-
-_fzf_complete_g_post() {
-  awk '{print "g" $0 $0}'
-}
-
-[ -n "${BASH-}" ] && complete -F _fzf_complete_f -o default -o bashdefault f
-[ -n "${BASH-}" ] && complete -F _fzf_complete_g -o default -o bashdefault g
-
-_comprun() {
-  local command=$1
-  shift
-
-  case "$command" in
-    f) fzf "$@" --preview 'echo preview-f-{}' ;;
-    g) fzf "$@" --preview 'echo preview-g-{}' ;;
-    *) fzf "$@" ;;
-  esac
-}
diff --git a/test/test_layout.rb b/test/test_layout.rb
new file mode 100644
index 00000000..5bf441d2
--- /dev/null
+++ b/test/test_layout.rb
@@ -0,0 +1,848 @@
+# frozen_string_literal: true
+
+require_relative 'lib/common'
+
+# Test cases that mainly use assert_block to verify the layout of fzf
+class TestLayout < TestInteractive
+  def assert_block(expected, lines)
+    cols = expected.lines.map { it.chomp.length }.max
+    top = lines.take(expected.lines.length).map { _1[0, cols].rstrip + "\n" }.join
+    bottom = lines.reverse.take(expected.lines.length).reverse.map { _1[0, cols].rstrip + "\n" }.join
+    assert_includes [top, bottom], expected
+  end
+
+  def test_vanilla
+    tmux.send_keys "seq 1 100000 | #{fzf}", :Enter
+    block = <<~BLOCK
+        2
+      > 1
+        100000/100000
+      >
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+
+    # Testing basic key bindings
+    tmux.send_keys '99', 'C-a', '1', 'C-f', '3', 'C-b', 'C-h', 'C-u', 'C-e', 'C-y', 'C-k', 'Tab', 'BTab'
+    block = <<~BLOCK
+      > 3910
+        391
+        856/100000
+      > 391
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+
+    tmux.send_keys :Enter
+    assert_equal '3910', fzf_output
+  end
+
+  def test_header_first
+    tmux.send_keys "seq 1000 | #{FZF} --header foobar --header-lines 3 --header-first", :Enter
+    block = <<~OUTPUT
+      > 4
+        997/997
+      >
+        3
+        2
+        1
+        foobar
+    OUTPUT
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_header_first_reverse
+    tmux.send_keys "seq 1000 | #{FZF} --header foobar --header-lines 3 --header-first --reverse --inline-info", :Enter
+    block = <<~OUTPUT
+        foobar
+        1
+        2
+        3
+      >   < 997/997
+      > 4
+    OUTPUT
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_change_and_transform_header
+    [
+      'space:change-header:$(seq 4)',
+      'space:transform-header:seq 4'
+    ].each_with_index do |binding, i|
+      tmux.send_keys %(seq 3 | #{FZF} --header-lines 2 --header bar --bind "#{binding}"), :Enter
+      expected = <<~OUTPUT
+        > 3
+          2
+          1
+          bar
+          1/1
+        >
+      OUTPUT
+      tmux.until { assert_block(expected, _1) }
+      tmux.send_keys :Space
+      expected = <<~OUTPUT
+        > 3
+          2
+          1
+          1
+          2
+          3
+          4
+          1/1
+        >
+      OUTPUT
+      tmux.until { assert_block(expected, _1) }
+      next unless i.zero?
+
+      teardown
+      setup
+    end
+  end
+
+  def test_change_header
+    tmux.send_keys %(seq 3 | #{FZF} --header-lines 2 --header bar --bind "space:change-header:$(seq 4)"), :Enter
+    expected = <<~OUTPUT
+      > 3
+        2
+        1
+        bar
+        1/1
+      >
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+    tmux.send_keys :Space
+    expected = <<~OUTPUT
+      > 3
+        2
+        1
+        1
+        2
+        3
+        4
+        1/1
+      >
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_reload_and_change_cache
+    tmux.send_keys "echo bar | #{FZF} --bind 'zero:change-header(foo)+reload(echo foo)+clear-query'", :Enter
+    expected = <<~OUTPUT
+      > bar
+        1/1
+      >
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+    tmux.send_keys :z
+    expected = <<~OUTPUT
+      > foo
+        foo
+        1/1
+      >
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_toggle_header
+    tmux.send_keys "seq 4 | #{FZF} --header-lines 2 --header foo --bind space:toggle-header --header-first --height 10 --border rounded", :Enter
+    before = <<~OUTPUT
+      ╭───────
+      │
+      │   4
+      │ > 3
+      │   2/2
+      │ >
+      │   2
+      │   1
+      │   foo
+      ╰───────
+    OUTPUT
+    tmux.until { assert_block(before, _1) }
+    tmux.send_keys :Space
+    after = <<~OUTPUT
+      ╭───────
+      │
+      │
+      │
+      │
+      │   4
+      │ > 3
+      │   2/2
+      │ >
+      ╰───────
+    OUTPUT
+    tmux.until { assert_block(after, _1) }
+    tmux.send_keys :Space
+    tmux.until { assert_block(before, _1) }
+  end
+
+  def test_height_range_fit
+    tmux.send_keys 'seq 3 | fzf --height ~100% --info=inline --border rounded', :Enter
+    expected = <<~OUTPUT
+      ╭──────────
+      │   3
+      │   2
+      │ > 1
+      │ >   < 3/3
+      ╰──────────
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_height_range_fit_preview_above
+    tmux.send_keys 'seq 3 | fzf --height ~100% --info=inline --border rounded --preview-window border-rounded --preview "seq {}" --preview-window up,60%', :Enter
+    expected = <<~OUTPUT
+      ╭──────────
+      │ ╭────────
+      │ │ 1
+      │ │
+      │ │
+      │ │
+      │ ╰────────
+      │   3
+      │   2
+      │ > 1
+      │ >   < 3/3
+      ╰──────────
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_height_range_fit_preview_above_alternative
+    tmux.send_keys 'seq 3 | fzf --height ~100% --border=sharp --preview "seq {}" --preview-window up,40%,border-bottom --padding 1 --exit-0 --header hello --header-lines=2', :Enter
+    expected = <<~OUTPUT
+      ┌─────────
+      │
+      │  1
+      │  2
+      │  3
+      │  ───────
+      │  > 3
+      │    2
+      │    1
+      │    hello
+      │    1/1 ─
+      │  >
+      │
+      └─────────
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_height_range_fit_preview_left
+    tmux.send_keys "seq 3 | fzf --height ~100% --border=vertical --preview 'seq {}' --preview-window left,5,border-right --padding 1 --exit-0 --header $'hello\\nworld' --header-lines=2", :Enter
+    expected = <<~OUTPUT
+      │
+      │  1     │ > 3
+      │  2     │   2
+      │  3     │   1
+      │        │   hello
+      │        │   world
+      │        │   1/1 ─
+      │        │ >
+      │
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_height_range_overflow
+    tmux.send_keys 'seq 100 | fzf --height ~5 --info=inline --border rounded', :Enter
+    expected = <<~OUTPUT
+      ╭──────────────
+      │   2
+      │ > 1
+      │ >   < 100/100
+      ╰──────────────
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_no_extra_newline_issue_3209
+    tmux.send_keys(%(seq 100 | #{FZF} --height 10 --preview-window up,wrap,border-rounded --preview 'printf "─%.0s" $(seq 1 "$((FZF_PREVIEW_COLUMNS - 5))"); printf $"\\e[7m%s\\e[0m" title; echo; echo something'), :Enter)
+    expected = <<~OUTPUT
+      ╭──────────
+      │ ─────────
+      │ something
+      │
+      ╰──────────
+        3
+        2
+      > 1
+        100/100 ─
+      >
+    OUTPUT
+    tmux.until { assert_block(expected, _1) }
+  end
+
+  def test_fzf_multi_line
+    tmux.send_keys %[(echo -en '0\\0'; echo -en '1\\n2\\0'; seq 1000) | fzf --read0 --multi --bind load:select-all --border rounded], :Enter
+    block = <<~BLOCK
+      │  ┃998
+      │  ┃999
+      │  ┃1000
+      │  ╹
+      │  ╻1
+      │  ╹2
+      │ >>0
+      │   3/3 (3)
+      │ >
+      ╰───────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+    tmux.send_keys :Up, :Up
+    block = <<~BLOCK
+      ╭───────
+      │ >╻1
+      │ >┃2
+      │ >┃3
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+
+    block = <<~BLOCK
+      │ >┃
+      │
+      │ >
+      ╰───
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_fzf_multi_line_reverse
+    tmux.send_keys %[(echo -en '0\\0'; echo -en '1\\n2\\0'; seq 1000) | fzf --read0 --multi --bind load:select-all --border rounded --reverse], :Enter
+    block = <<~BLOCK
+      ╭───────────
+      │ >
+      │   3/3 (3)
+      │ >>0
+      │  ╻1
+      │  ╹2
+      │  ╻1
+      │  ┃2
+      │  ┃3
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_fzf_multi_line_no_pointer_and_marker
+    tmux.send_keys %[(echo -en '0\\0'; echo -en '1\\n2\\0'; seq 1000) | fzf --read0 --multi --bind load:select-all --border rounded --reverse --pointer '' --marker '' --marker-multi-line ''], :Enter
+    block = <<~BLOCK
+      ╭───────────
+      │ >
+      │   3/3 (3)
+      │ 0
+      │ 1
+      │ 2
+      │ 1
+      │ 2
+      │ 3
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_gap
+    tmux.send_keys %(seq 100 | #{FZF} --gap --border --reverse), :Enter
+    block = <<~BLOCK
+      ╭─────────────────
+      │ >
+      │   100/100 ──────
+      │ > 1
+      │   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈
+      │   2
+      │   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈
+      │   3
+      │   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈
+      │   4
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_gap_2
+    tmux.send_keys %(seq 100 | #{FZF} --gap=2 --gap-line xyz --border --reverse), :Enter
+    block = <<~BLOCK
+      ╭─────────────────
+      │ >
+      │   100/100 ──────
+      │ > 1
+      │
+      │   xyzxyzxyzxyzxy
+      │   2
+      │
+      │   xyzxyzxyzxyzxy
+      │   3
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_list_border_and_label
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --query 1 --padding 1,2), :Enter
+    block = <<~BLOCK
+      │   ║   11
+      │   ║ > 10
+      │   ║   3
+      │   ║   2
+      │   ║   1
+      │   ║   19/97 ─
+      │   ║ > 1
+      │   ╚list══════
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_input_border_and_label
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --input-border bold --input-label input --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2), :Enter
+    block = <<~BLOCK
+      │     11
+      │   > 10
+      │     3
+      │     2
+      │     1
+      │   ┏input━━━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗━━━━━━━━━━
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_input_border_and_label_header_first
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --input-border bold --input-label input --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2 --header-first), :Enter
+    block = <<~BLOCK
+      │     11
+      │   > 10
+      │   ┏input━━━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗━━━━━━━━━━
+      │     3
+      │     2
+      │     1
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_list_input_border_and_label
+    tmux.send_keys %(
+      seq 100 | #{FZF} --border rounded --list-border double --input-border bold --list-label-pos 2:bottom --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2 \
+      --bind 'start:transform-input-label(echo INPUT)+transform-list-label(echo LIST)' \
+      --bind 'space:change-input-label( input )+change-list-label( list )'
+    ).strip, :Enter
+    block = <<~BLOCK
+      │   ║   11
+      │   ║ > 10
+      │   ╚LIST══════
+      │       3
+      │       2
+      │       1
+      │   ┏INPUT━━━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗━━━━━━━━━━
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+    tmux.send_keys :Space
+    block = <<~BLOCK
+      │   ║   11
+      │   ║ > 10
+      │   ╚ list ════
+      │       3
+      │       2
+      │       1
+      │   ┏ input ━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗━━━━━━━━━━
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_list_input_border_and_label_header_first
+    tmux.send_keys %(
+      seq 100 | #{FZF} --border rounded --list-border double --input-border bold --list-label-pos 2:bottom --input-label-pos 2 --header-lines 3 --query 1 --padding 1,2 \
+      --bind 'start:transform-input-label(echo INPUT)+transform-list-label(echo LIST)' \
+      --bind 'space:change-input-label( input )+change-list-label( list )' --header-first
+    ).strip, :Enter
+    block = <<~BLOCK
+      │   ║   11
+      │   ║ > 10
+      │   ╚LIST══════
+      │   ┏INPUT━━━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗━━━━━━━━━━
+      │       3
+      │       2
+      │       1
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+    tmux.send_keys :Space
+    block = <<~BLOCK
+      │   ║   11
+      │   ║ > 10
+      │   ╚ list ════
+      │   ┏ input ━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗━━━━━━━━━━
+      │       3
+      │       2
+      │       1
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_header_border_and_label
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2), :Enter
+    block = <<~BLOCK
+      │     12
+      │     11
+      │   > 10
+      │   ┌────────
+      │   │ 3
+      │   │ 2
+      │   │ 1
+      │   └header──
+      │     19/97 ─
+      │   > 1
+      │
+      ╰────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_header_border_toggle
+    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()'), :Enter
+    block1 = <<~BLOCK
+      │   5
+      │   4
+      │   3
+      │   2
+      │ > 1
+      │   100/100 ─
+      │ >
+      ╰────────────
+    BLOCK
+    tmux.until { assert_block(block1, _1) }
+
+    tmux.send_keys :Space
+    block2 = <<~BLOCK
+      │   3
+      │   2
+      │ > 1
+      ╰────────────
+      ╭────────────
+      │   hello
+      ╰────────────
+          100/100 ─
+        >
+    BLOCK
+    tmux.until { assert_block(block2, _1) }
+
+    tmux.send_keys :Enter
+    tmux.until { assert_block(block1, _1) }
+  end
+
+  def test_header_border_toggle_with_header_lines
+    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2), :Enter
+    block1 = <<~BLOCK
+      │   5
+      │   4
+      │ > 3
+      ╰──────────
+      ╭──────────
+      │   2
+      │   1
+      ╰──────────
+          98/98 ─
+        >
+    BLOCK
+    tmux.until { assert_block(block1, _1) }
+
+    tmux.send_keys :Space
+    block2 = <<~BLOCK
+      │   4
+      │ > 3
+      ╰──────────
+      ╭──────────
+      │   2
+      │   1
+      │   hello
+      ╰──────────
+          98/98 ─
+        >
+    BLOCK
+    tmux.until { assert_block(block2, _1) }
+
+    tmux.send_keys :Enter
+    tmux.until { assert_block(block1, _1) }
+  end
+
+  def test_header_border_toggle_with_header_lines_header_first
+    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2 --header-first), :Enter
+    block1 = <<~BLOCK
+      │   5
+      │   4
+      │ > 3
+      ╰──────────
+          98/98 ─
+        >
+      ╭──────────
+      │   2
+      │   1
+      ╰──────────
+    BLOCK
+    tmux.until { assert_block(block1, _1) }
+
+    tmux.send_keys :Space
+    block2 = <<~BLOCK
+      │   4
+      │ > 3
+      ╰──────────
+          98/98 ─
+        >
+      ╭──────────
+      │   2
+      │   1
+      │   hello
+      ╰──────────
+    BLOCK
+    tmux.until { assert_block(block2, _1) }
+
+    tmux.send_keys :Enter
+    tmux.until { assert_block(block1, _1) }
+  end
+
+  def test_header_border_toggle_with_header_lines_header_lines_border
+    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2 --header-lines-border double), :Enter
+    block1 = <<~BLOCK
+      │   5
+      │   4
+      │ > 3
+      ╰──────────
+      ╔══════════
+      ║   2
+      ║   1
+      ╚══════════
+          98/98 ─
+        >
+    BLOCK
+    tmux.until { assert_block(block1, _1) }
+
+    tmux.send_keys :Space
+    block2 = <<~BLOCK
+      │ > 3
+      ╰──────────
+      ╔══════════
+      ║   2
+      ║   1
+      ╚══════════
+      ╭──────────
+      │   hello
+      ╰──────────
+          98/98 ─
+        >
+    BLOCK
+    tmux.until { assert_block(block2, _1) }
+
+    tmux.send_keys :Enter
+    tmux.until { assert_block(block1, _1) }
+  end
+
+  def test_header_border_toggle_with_header_lines_header_first_header_lines_border
+    tmux.send_keys %(seq 100 | #{FZF} --list-border rounded --header-border rounded --bind 'space:change-header(hello),enter:change-header()' --header-lines 2 --header-first --header-lines-border double), :Enter
+    block1 = <<~BLOCK
+      │   5
+      │   4
+      │ > 3
+      ╰──────────
+      ╔══════════
+      ║   2
+      ║   1
+      ╚══════════
+          98/98 ─
+        >
+    BLOCK
+    tmux.until { assert_block(block1, _1) }
+
+    tmux.send_keys :Space
+    block2 = <<~BLOCK
+      │ > 3
+      ╰──────────
+      ╔══════════
+      ║   2
+      ║   1
+      ╚══════════
+          98/98 ─
+        >
+      ╭──────────
+      │   hello
+      ╰──────────
+    BLOCK
+    tmux.until { assert_block(block2, _1) }
+
+    tmux.send_keys :Enter
+    tmux.until { assert_block(block1, _1) }
+  end
+
+  def test_header_border_and_label_header_first
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --header-first), :Enter
+    block = <<~BLOCK
+      │     12
+      │     11
+      │   > 10
+      │     19/97 ─
+      │   > 1
+      │   ┌────────
+      │   │ 3
+      │   │ 2
+      │   │ 1
+      │   └header──
+      │
+      ╰────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_header_border_and_label_with_list_border
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2), :Enter
+    block = <<~BLOCK
+      │   ║   12
+      │   ║   11
+      │   ║ > 10
+      │   ╚list══════
+      │   ┌──────────
+      │   │   3
+      │   │   2
+      │   │   1
+      │   └header────
+      │       19/97 ─
+      │     > 1
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_header_border_and_label_with_list_border_header_first
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --header-first), :Enter
+    block = <<~BLOCK
+      │   ║   12
+      │   ║   11
+      │   ║ > 10
+      │   ╚list══════
+      │       19/97 ─
+      │     > 1
+      │   ┌──────────
+      │   │   3
+      │   │   2
+      │   │   1
+      │   └header────
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_all_borders
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --input-border bold --input-label input --input-label-pos 2:bottom), :Enter
+    block = <<~BLOCK
+      │   ║   12
+      │   ║   11
+      │   ║ > 10
+      │   ╚list══════
+      │   ┌──────────
+      │   │   3
+      │   │   2
+      │   │   1
+      │   └header────
+      │   ┏━━━━━━━━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗input━━━━━
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_all_borders_header_first
+    tmux.send_keys %(seq 100 | #{FZF} --border rounded --list-border double --list-label list --list-label-pos 2:bottom --header-lines 3 --header-border sharp --header-label header --header-label-pos 2:bottom --query 1 --padding 1,2 --input-border bold --input-label input --input-label-pos 2:bottom --header-first), :Enter
+    block = <<~BLOCK
+      │   ║   12
+      │   ║   11
+      │   ║ > 10
+      │   ╚list══════
+      │   ┏━━━━━━━━━━
+      │   ┃   19/97
+      │   ┃ > 1
+      │   ┗input━━━━━
+      │   ┌──────────
+      │   │   3
+      │   │   2
+      │   │   1
+      │   └header────
+      │
+      ╰──────────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_style_full_adaptive_height
+    tmux.send_keys %(seq 1| #{FZF} --style=full --height=~100% --header-lines=1 --info=default), :Enter
+    block = <<~BLOCK
+      ╭────────
+      ╰────────
+      ╭────────
+      │   1
+      ╰────────
+      ╭────────
+      │   0/0
+      │ >
+      ╰────────
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_style_full_adaptive_height_double
+    tmux.send_keys %(seq 1| #{FZF} --style=full:double --border --height=~100% --header-lines=1 --info=default), :Enter
+    block = <<~BLOCK
+      ╔══════════
+      ║ ╔════════
+      ║ ╚════════
+      ║ ╔════════
+      ║ ║   1
+      ║ ╚════════
+      ║ ╔════════
+      ║ ║   0/0
+      ║ ║ >
+      ║ ╚════════
+      ╚══════════
+    BLOCK
+    tmux.until { assert_block(block, _1) }
+  end
+
+  def test_preview_window_noinfo
+    # │ 1        ││
+    tmux.send_keys %(#{FZF} --preview 'seq 1000' --preview-window top,noinfo --scrollbar --bind space:change-preview-window:info), :Enter
+    tmux.until do |lines|
+      assert lines[1]&.start_with?('│ 1')
+      assert lines[1]&.end_with?('  ││')
+    end
+    tmux.send_keys :Space
+    tmux.until do |lines|
+      assert lines[1]&.start_with?('│ 1')
+      assert lines[1]&.end_with?('1000││')
+    end
+  end
+end
diff --git a/test/test_preview.rb b/test/test_preview.rb
new file mode 100644
index 00000000..356d23a4
--- /dev/null
+++ b/test/test_preview.rb
@@ -0,0 +1,545 @@
+# frozen_string_literal: true
+
+require_relative 'lib/common'
+
+# Test cases for preview
+class TestPreview < TestInteractive
+  def test_preview
+    tmux.send_keys %(seq 1000 | sed s/^2$// | #{FZF} -m --preview 'sleep 0.2; echo {{}-{+}}' --bind ?:toggle-preview), :Enter
+    tmux.until { |lines| assert_includes lines[1], ' {1-1} ' }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines[1], ' {-} ' }
+    tmux.send_keys '555'
+    tmux.until { |lines| assert_includes lines[1], ' {555-555} ' }
+    tmux.send_keys '?'
+    tmux.until { |lines| refute_includes lines[1], ' {555-555} ' }
+    tmux.send_keys '?'
+    tmux.until { |lines| assert_includes lines[1], ' {555-555} ' }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert lines[-2]&.start_with?('  28/1000 ') }
+    tmux.send_keys 'foobar'
+    tmux.until { |lines| refute_includes lines[1], ' {55-55} ' }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| assert_equal 1000, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' {1-1} ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' {-1} ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' {3-1 } ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' {4-1  3} ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' {5-1  3 4} ' }
+  end
+
+  def test_toggle_preview_without_default_preview_command
+    tmux.send_keys %(seq 100 | #{FZF} --bind 'space:preview(echo [{}]),enter:toggle-preview' --preview-window up,border-double), :Enter
+    tmux.until do |lines|
+      assert_equal 100, lines.match_count
+      refute_includes lines[1], '║ [1]'
+    end
+
+    # toggle-preview should do nothing
+    tmux.send_keys :Enter
+    tmux.until { |lines| refute_includes lines[1], '║ [1]' }
+    tmux.send_keys :Up
+    tmux.until do |lines|
+      refute_includes lines[1], '║ [1]'
+      refute_includes lines[1], '║ [2]'
+    end
+
+    tmux.send_keys :Up
+    tmux.until do |lines|
+      assert_includes lines, '> 3'
+      refute_includes lines[1], '║ [3]'
+    end
+
+    # One-off preview action
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_includes lines[1], '║ [3]' }
+
+    # toggle-preview to hide it
+    tmux.send_keys :Enter
+    tmux.until { |lines| refute_includes lines[1], '║ [3]' }
+
+    # toggle-preview again does nothing
+    tmux.send_keys :Enter, :Up
+    tmux.until do |lines|
+      assert_includes lines, '> 4'
+      refute_includes lines[1], '║ [4]'
+    end
+  end
+
+  def test_show_and_hide_preview
+    tmux.send_keys %(seq 100 | #{FZF} --preview-window hidden,border-bold --preview 'echo [{}]' --bind 'a:show-preview,b:hide-preview'), :Enter
+
+    # Hidden by default
+    tmux.until do |lines|
+      assert_equal 100, lines.match_count
+      refute_includes lines[1], '┃ [1]'
+    end
+
+    # Show
+    tmux.send_keys :a
+    tmux.until { |lines| assert_includes lines[1], '┃ [1]' }
+
+    # Already shown
+    tmux.send_keys :a
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines[1], '┃ [2]' }
+
+    # Hide
+    tmux.send_keys :b
+    tmux.send_keys :Up
+    tmux.until do |lines|
+      assert_includes lines, '> 3'
+      refute_includes lines[1], '┃ [3]'
+    end
+
+    # Already hidden
+    tmux.send_keys :b
+    tmux.send_keys :Up
+    tmux.until do |lines|
+      assert_includes lines, '> 4'
+      refute_includes lines[1], '┃ [4]'
+    end
+
+    # Show it again
+    tmux.send_keys :a
+    tmux.until { |lines| assert_includes lines[1], '┃ [4]' }
+  end
+
+  def test_preview_hidden
+    tmux.send_keys %(seq 1000 | #{FZF} --preview 'echo {{}-{}-$FZF_PREVIEW_LINES-$FZF_PREVIEW_COLUMNS}' --preview-window down:1:hidden --bind ?:toggle-preview), :Enter
+    tmux.until { |lines| assert_equal '>', lines[-1] }
+    tmux.send_keys '?'
+    tmux.until { |lines| assert_match(/ {1-1-1-[0-9]+}/, lines[-2]) }
+    tmux.send_keys '555'
+    tmux.until { |lines| assert_match(/ {555-555-1-[0-9]+}/, lines[-2]) }
+    tmux.send_keys '?'
+    tmux.until { |lines| assert_equal '> 555', lines[-1] }
+  end
+
+  def test_preview_size_0
+    tmux.send_keys %(seq 100 | #{FZF} --reverse --preview 'echo {} >> #{tempname}; echo ' --preview-window 0 --bind space:toggle-preview), :Enter
+    tmux.until do |lines|
+      assert_equal 100, lines.item_count
+      assert_equal '  100/100', lines[1]
+      assert_equal '> 1', lines[2]
+    end
+    wait do
+      assert_path_exists tempname
+      assert_equal %w[1], File.readlines(tempname, chomp: true)
+    end
+    tmux.send_keys :Space, :Down, :Down
+    tmux.until { |lines| assert_equal '> 3', lines[4] }
+    wait do
+      assert_path_exists tempname
+      assert_equal %w[1], File.readlines(tempname, chomp: true)
+    end
+    tmux.send_keys :Space, :Down
+    tmux.until { |lines| assert_equal '> 4', lines[5] }
+    wait do
+      assert_path_exists tempname
+      assert_equal %w[1 3 4], File.readlines(tempname, chomp: true)
+    end
+  end
+
+  def test_preview_size_0_hidden
+    tmux.send_keys %(seq 100 | #{FZF} --reverse --preview 'echo {} >> #{tempname}; echo ' --preview-window 0,hidden --bind space:toggle-preview), :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys :Down, :Down
+    tmux.until { |lines| assert_includes lines, '> 3' }
+    wait { refute_path_exists tempname }
+    tmux.send_keys :Space
+    wait do
+      assert_path_exists tempname
+      assert_equal %w[3], File.readlines(tempname, chomp: true)
+    end
+    tmux.send_keys :Down
+    wait do
+      assert_equal %w[3 4], File.readlines(tempname, chomp: true)
+    end
+    tmux.send_keys :Space, :Down
+    tmux.until { |lines| assert_includes lines, '> 5' }
+    tmux.send_keys :Down
+    tmux.until { |lines| assert_includes lines, '> 6' }
+    tmux.send_keys :Space
+    wait do
+      assert_equal %w[3 4 6], File.readlines(tempname, chomp: true)
+    end
+  end
+
+  def test_preview_flags
+    tmux.send_keys %(seq 10 | sed 's/^/:: /; s/$/  /' |
+        #{FZF} --multi --preview 'echo {{2}/{s2}/{+2}/{+s2}/{q}/{n}/{+n}}'), :Enter
+    tmux.until { |lines| assert_includes lines[1], ' {1/1  /1/1  //0/0} ' }
+    tmux.send_keys '123'
+    tmux.until { |lines| assert_includes lines[1], ' {////123//} ' }
+    tmux.send_keys 'C-u', '1'
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' {1/1  /1/1  /1/0/0} ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' {10/10  /1/1  /1/9/0} ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' {10/10  /1 10/1   10  /1/9/0 9} ' }
+    tmux.send_keys '2'
+    tmux.until { |lines| assert_includes lines[1], ' {//1 10/1   10  /12//0 9} ' }
+    tmux.send_keys '3'
+    tmux.until { |lines| assert_includes lines[1], ' {//1 10/1   10  /123//0 9} ' }
+  end
+
+  def test_preview_file
+    tmux.send_keys %[(echo foo bar; echo bar foo) | #{FZF} --multi --preview 'cat {+f} {+f2} {+nf} {+fn}' --print0], :Enter
+    tmux.until { |lines| assert_includes lines[1], ' foo barbar00 ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' foo barbar00 ' }
+    tmux.send_keys :BTab
+    tmux.until { |lines| assert_includes lines[1], ' foo barbar foobarfoo0101 ' }
+  end
+
+  def test_preview_q_no_match
+    tmux.send_keys %(: | #{FZF} --preview 'echo foo {q} foo'), :Enter
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' foo  foo' }
+    tmux.send_keys 'bar'
+    tmux.until { |lines| assert_includes lines[1], ' foo bar foo' }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| assert_includes lines[1], ' foo  foo' }
+  end
+
+  def test_preview_q_no_match_with_initial_query
+    tmux.send_keys %(: | #{FZF} --preview 'echo foo {q}{q}' --query foo), :Enter
+    tmux.until { |lines| assert_equal 0, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], ' foofoo ' }
+  end
+
+  def test_preview_update_on_select
+    tmux.send_keys %(seq 10 | fzf -m --preview 'echo {+}' --bind a:toggle-all),
+                   :Enter
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert(lines.any? { |line| line.include?(' 1 2 3 4 5 ') }) }
+    tmux.send_keys 'a'
+    tmux.until { |lines| lines.each { |line| refute_includes line, ' 1 2 3 4 5 ' } }
+  end
+
+  def test_preview_correct_tab_width_after_ansi_reset_code
+    writelines(["\x1b[31m+\x1b[m\t\x1b[32mgreen"])
+    tmux.send_keys "#{FZF} --preview 'cat #{tempname}'", :Enter
+    tmux.until { |lines| assert_includes lines[1], ' +       green ' }
+  end
+
+  def test_preview_bindings_with_default_preview
+    tmux.send_keys "seq 10 | #{FZF} --preview 'echo [{}]' --bind 'a:preview(echo [{}{}]),b:preview(echo [{}{}{}]),c:refresh-preview'", :Enter
+    tmux.until { |lines| lines.item_count == 10 }
+    tmux.until { |lines| assert_includes lines[1], '[1]' }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_includes lines[1], '[11]' }
+    tmux.send_keys 'c'
+    tmux.until { |lines| assert_includes lines[1], '[1]' }
+    tmux.send_keys 'b'
+    tmux.until { |lines| assert_includes lines[1], '[111]' }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines[1], '[2]' }
+  end
+
+  def test_preview_bindings_without_default_preview
+    tmux.send_keys "seq 10 | #{FZF} --bind 'a:preview(echo [{}{}]),b:preview(echo [{}{}{}]),c:refresh-preview'", :Enter
+    tmux.until { |lines| lines.item_count == 10 }
+    tmux.until { |lines| refute_includes lines[1], '1' }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_includes lines[1], '[11]' }
+    tmux.send_keys 'c' # does nothing
+    tmux.until { |lines| assert_includes lines[1], '[11]' }
+    tmux.send_keys 'b'
+    tmux.until { |lines| assert_includes lines[1], '[111]' }
+    tmux.send_keys 9
+    tmux.until { |lines| lines.match_count == 1 }
+    tmux.until { |lines| refute_includes lines[1], '2' }
+    tmux.until { |lines| assert_includes lines[1], '[111]' }
+  end
+
+  def test_preview_scroll_begin_constant
+    tmux.send_keys "echo foo 123 321 | #{FZF} --preview 'seq 1000' --preview-window left:+123", :Enter
+    tmux.until { |lines| assert_match %r{1/1}, lines[-2] }
+    tmux.until { |lines| assert_match %r{123.*123/1000}, lines[1] }
+  end
+
+  def test_preview_scroll_begin_expr
+    tmux.send_keys "echo foo 123 321 | #{FZF} --preview 'seq 1000' --preview-window left:+{3}", :Enter
+    tmux.until { |lines| assert_match %r{1/1}, lines[-2] }
+    tmux.until { |lines| assert_match %r{321.*321/1000}, lines[1] }
+  end
+
+  def test_preview_scroll_begin_and_offset
+    ['echo foo 123 321', 'echo foo :123: 321'].each do |input|
+      tmux.send_keys "#{input} | #{FZF} --preview 'seq 1000' --preview-window left:+{2}-2", :Enter
+      tmux.until { |lines| assert_match %r{1/1}, lines[-2] }
+      tmux.until { |lines| assert_match %r{121.*121/1000}, lines[1] }
+      tmux.send_keys 'C-c'
+    end
+  end
+
+  def test_preview_clear_screen
+    tmux.send_keys %{seq 100 | #{FZF} --preview 'for i in $(seq 300); do (( i % 200 == 0 )) && printf "\\033[2J"; echo "[$i]"; sleep 0.001; done'}, :Enter
+    tmux.until { |lines| lines.item_count == 100 }
+    tmux.until { |lines| lines[1]&.include?('[200]') }
+  end
+
+  def test_preview_window_follow
+    file = Tempfile.new('fzf-follow')
+    file.sync = true
+
+    tmux.send_keys %(seq 100 | #{FZF} --preview 'echo start; tail -f "#{file.path}"' --preview-window follow --bind 'up:preview-up,down:preview-down,space:change-preview-window:follow|nofollow' --preview-window '~4'), :Enter
+    tmux.until { |lines| lines.item_count == 100 }
+
+    # Write to the temporary file, and check if the preview window is showing
+    # the last line of the file
+    tmux.until { |lines| assert_includes lines[1], 'start' }
+    3.times { file.puts _1 } # header lines
+    1000.times { file.puts _1 }
+    tmux.until { |lines| assert_includes lines[1], '/1004' }
+    tmux.until { |lines| assert_includes lines[-2], '999' }
+
+    # Scroll the preview window and fzf should stop following the file content
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines[-2], '998' }
+    file.puts 'foo', 'bar'
+    tmux.until do |lines|
+      assert_includes lines[1], '/1006'
+      assert_includes lines[-2], '998'
+    end
+
+    # Scroll back to the bottom and fzf should start following the file again
+    %w[999 foo bar].each do |item|
+      wait do
+        tmux.send_keys :Down
+        tmux.until { |lines| assert_includes lines[-2], item }
+      end
+    end
+    file.puts 'baz'
+    tmux.until do |lines|
+      assert_includes lines[1], '/1007'
+      assert_includes lines[-2], 'baz'
+    end
+
+    # Scroll upwards to stop following
+    tmux.send_keys :Up
+    wait { assert_includes lines[-2], 'bar' }
+    file.puts 'aaa'
+    tmux.until do |lines|
+      assert_includes lines[1], '/1008'
+      assert_includes lines[-2], 'bar'
+    end
+
+    # Manually enable following
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_includes lines[-2], 'aaa' }
+    file.puts 'bbb'
+    tmux.until do |lines|
+      assert_includes lines[1], '/1009'
+      assert_includes lines[-2], 'bbb'
+    end
+
+    # Disable following
+    tmux.send_keys :Space
+    file.puts 'ccc', 'ddd'
+    tmux.until do |lines|
+      assert_includes lines[1], '/1011'
+      assert_includes lines[-2], 'bbb'
+    end
+  rescue StandardError
+    file.close
+    file.unlink
+  end
+
+  def test_toggle_preview_wrap
+    tmux.send_keys "#{FZF} --preview 'for i in $(seq $FZF_PREVIEW_COLUMNS); do echo -n .; done; echo wrapped; echo 2nd line' --bind ctrl-w:toggle-preview-wrap", :Enter
+    2.times do
+      tmux.until { |lines| assert_includes lines[2], '2nd line' }
+      tmux.send_keys 'C-w'
+      tmux.until do |lines|
+        assert_includes lines[2], 'wrapped'
+        assert_includes lines[3], '2nd line'
+      end
+      tmux.send_keys 'C-w'
+    end
+  end
+
+  def test_close
+    tmux.send_keys "seq 100 | #{FZF} --preview 'echo foo' --bind ctrl-c:close", :Enter
+    tmux.until { |lines| assert_equal 100, lines.match_count }
+    tmux.until { |lines| assert_includes lines[1], 'foo' }
+    tmux.send_keys 'C-c'
+    tmux.until { |lines| refute_includes lines[1], 'foo' }
+    tmux.send_keys '10'
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+    tmux.send_keys 'C-c'
+    tmux.send_keys 'C-l', 'closed'
+    tmux.until { |lines| assert_includes lines[0], 'closed' }
+  end
+
+  def test_preview_header
+    tmux.send_keys "seq 100 | #{FZF} --bind ctrl-k:preview-up+preview-up,ctrl-j:preview-down+preview-down+preview-down --preview 'seq 1000' --preview-window 'top:+{1}:~3'", :Enter
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    top5 = ->(lines) { lines.drop(1).take(5).map { |s| s[/[0-9]+/] } }
+    tmux.until do |lines|
+      assert_includes lines[1], '4/1000'
+      assert_equal(%w[1 2 3 4 5], top5[lines])
+    end
+    tmux.send_keys '55'
+    tmux.until do |lines|
+      assert_equal 1, lines.match_count
+      assert_equal(%w[1 2 3 55 56], top5[lines])
+    end
+    tmux.send_keys 'C-J'
+    tmux.until do |lines|
+      assert_equal(%w[1 2 3 58 59], top5[lines])
+    end
+    tmux.send_keys :BSpace
+    tmux.until do |lines|
+      assert_equal 19, lines.match_count
+      assert_equal(%w[1 2 3 5 6], top5[lines])
+    end
+    tmux.send_keys 'C-K'
+    tmux.until { |lines| assert_equal(%w[1 2 3 4 5], top5[lines]) }
+  end
+
+  def test_change_preview_window
+    tmux.send_keys "seq 1000 | #{FZF} --preview 'echo [[{}]]' --no-preview-border --bind '" \
+                   'a:change-preview(echo __{}__),' \
+                   'b:change-preview-window(down)+change-preview(echo =={}==)+change-preview-window(up),' \
+                   'c:change-preview(),d:change-preview-window(hidden),' \
+                   "e:preview(printf ::%${FZF_PREVIEW_COLUMNS}s{})+change-preview-window(up),f:change-preview-window(up,wrap)'", :Enter
+    tmux.until { |lines| assert_equal 1000, lines.item_count }
+    tmux.until { |lines| assert_includes lines[0], '[[1]]' }
+
+    # change-preview action permanently changes the preview command set by --preview
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_includes lines[0], '__1__' }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines[0], '__2__' }
+
+    # When multiple change-preview-window actions are bound to a single key,
+    # the last one wins and the updated options are immediately applied to the new preview
+    tmux.send_keys 'b'
+    tmux.until { |lines| assert_equal '==2==', lines[0] }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_equal '==3==', lines[0] }
+
+    # change-preview with an empty preview command closes the preview window
+    tmux.send_keys 'c'
+    tmux.until { |lines| refute_includes lines[0], '==' }
+
+    # change-preview again to re-open the preview window
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_equal '__3__', lines[0] }
+
+    # Hide the preview window with hidden flag
+    tmux.send_keys 'd'
+    tmux.until { |lines| refute_includes lines[0], '__3__' }
+
+    # One-off preview
+    tmux.send_keys 'e'
+    tmux.until do |lines|
+      assert_equal '::', lines[0]
+      refute_includes lines[1], '3'
+    end
+
+    # Wrapped
+    tmux.send_keys 'f'
+    tmux.until do |lines|
+      assert_equal '::', lines[0]
+      assert_equal '  3', lines[1]
+    end
+  end
+
+  def test_change_preview_window_should_not_reset_change_preview
+    tmux.send_keys "#{FZF} --preview-window up,border-none --bind 'start:change-preview(echo hello)' --bind 'enter:change-preview-window(border-left)'", :Enter
+    tmux.until { |lines| assert_includes lines, 'hello' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_includes lines, '│ hello' }
+  end
+
+  def test_change_preview_window_rotate
+    tmux.send_keys "seq 100 | #{FZF} --preview-window left,border-none --preview 'echo hello' --bind '" \
+                   "a:change-preview-window(right|down|up|hidden|)'", :Enter
+    tmux.until { |lines| assert(lines.any? { _1.include?('100/100') }) }
+    3.times do
+      tmux.until { |lines| lines[0].start_with?('hello') }
+      tmux.send_keys 'a'
+      tmux.until { |lines| lines[0].end_with?('hello') }
+      tmux.send_keys 'a'
+      tmux.until { |lines| lines[-1].start_with?('hello') }
+      tmux.send_keys 'a'
+      tmux.until { |lines| assert_equal 'hello', lines[0] }
+      tmux.send_keys 'a'
+      tmux.until { |lines| refute_includes lines[0], 'hello' }
+      tmux.send_keys 'a'
+    end
+  end
+
+  def test_change_preview_window_rotate_hidden
+    tmux.send_keys "seq 100 | #{FZF} --preview-window hidden --preview 'echo =={}==' --bind '" \
+                   "a:change-preview-window(nohidden||down,1|)'", :Enter
+    tmux.until { |lines| assert_equal 100, lines.match_count }
+    tmux.until { |lines| refute_includes lines[1], '==1==' }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_includes lines[1], '==1==' }
+    tmux.send_keys 'a'
+    tmux.until { |lines| refute_includes lines[1], '==1==' }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_includes lines[-2], '==1==' }
+    tmux.send_keys 'a'
+    tmux.until { |lines| refute_includes lines[-2], '==1==' }
+    tmux.send_keys 'a'
+    tmux.until { |lines| assert_includes lines[1], '==1==' }
+  end
+
+  def test_change_preview_window_rotate_hidden_down
+    tmux.send_keys "seq 100 | #{FZF} --bind '?:change-preview-window:up||down|' --preview 'echo =={}==' --preview-window hidden,down,1", :Enter
+    tmux.until { |lines| assert_equal 100, lines.match_count }
+    tmux.until { |lines| refute_includes lines[1], '==1==' }
+    tmux.send_keys '?'
+    tmux.until { |lines| assert_includes lines[1], '==1==' }
+    tmux.send_keys '?'
+    tmux.until { |lines| refute_includes lines[1], '==1==' }
+    tmux.send_keys '?'
+    tmux.until { |lines| assert_includes lines[-2], '==1==' }
+    tmux.send_keys '?'
+    tmux.until { |lines| refute_includes lines[-2], '==1==' }
+    tmux.send_keys '?'
+    tmux.until { |lines| assert_includes lines[1], '==1==' }
+  end
+
+  def test_toggle_alternative_preview_window
+    tmux.send_keys "seq 10 | #{FZF} --bind space:toggle-preview --preview-window '<100000(hidden,up,border-none)' --preview 'echo /{}/{}/'", :Enter
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+    tmux.until { |lines| refute_includes lines, '/1/1/' }
+    tmux.send_keys :Space
+    tmux.until { |lines| assert_includes lines, '/1/1/' }
+  end
+
+  def test_alternative_preview_window_opts
+    tmux.send_keys "seq 10 | #{FZF} --preview-window '~5,2,+0,<100000(~0,+100,wrap,noinfo)' --preview 'seq 1000'", :Enter
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+    tmux.until do |lines|
+      assert_equal ['╭────╮', '│ 10 │', '│ 0  │', '│ 10 │', '│ 1  │'], lines.take(5).map(&:strip)
+    end
+  end
+
+  def test_preview_window_width_exception
+    tmux.send_keys "seq 10 | #{FZF} --scrollbar --preview-window border-left --border --preview 'seq 1000'", :Enter
+    tmux.until do |lines|
+      assert lines[1]&.end_with?(' 1/1000││')
+    end
+  end
+
+  def test_preview_window_hidden_on_focus
+    tmux.send_keys "seq 3 | #{FZF} --preview 'echo {}' --bind focus:hide-preview", :Enter
+    tmux.until { |lines| assert_includes lines, '> 1' }
+    tmux.send_keys :Up
+    tmux.until { |lines| assert_includes lines, '> 2' }
+  end
+end
diff --git a/test/test_server.rb b/test/test_server.rb
new file mode 100644
index 00000000..e30d50c9
--- /dev/null
+++ b/test/test_server.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'lib/common'
+
+# Test cases for API server
+class TestServer < TestInteractive
+  def test_listen
+    { '--listen 6266' => -> { URI('http://localhost:6266') },
+      "--listen --sync --bind 'start:execute-silent:echo $FZF_PORT > /tmp/fzf-port'" =>
+        -> { URI("http://localhost:#{File.read('/tmp/fzf-port').chomp}") } }.each do |opts, fn|
+      tmux.send_keys "seq 10 | fzf #{opts}", :Enter
+      tmux.until { |lines| assert_equal 10, lines.item_count }
+      state = JSON.parse(Net::HTTP.get(fn.call), symbolize_names: true)
+      assert_equal 10, state[:totalCount]
+      assert_equal 10, state[:matchCount]
+      assert_empty state[:query]
+      assert_equal({ index: 0, text: '1' }, state[:current])
+
+      Net::HTTP.post(fn.call, 'change-query(yo)+reload(seq 100)+change-prompt:hundred> ')
+      tmux.until { |lines| assert_equal 100, lines.item_count }
+      tmux.until { |lines| assert_equal 'hundred> yo', lines[-1] }
+      state = JSON.parse(Net::HTTP.get(fn.call), symbolize_names: true)
+      assert_equal 100, state[:totalCount]
+      assert_equal 0, state[:matchCount]
+      assert_equal 'yo', state[:query]
+      assert_nil state[:current]
+
+      teardown
+      setup
+    end
+  end
+
+  def test_listen_with_api_key
+    post_uri = URI('http://localhost:6266')
+    tmux.send_keys 'seq 10 | FZF_API_KEY=123abc fzf --listen 6266', :Enter
+    tmux.until { |lines| assert_equal 10, lines.item_count }
+    # Incorrect API Key
+    [nil, { 'x-api-key' => '' }, { 'x-api-key' => '124abc' }].each do |headers|
+      res = Net::HTTP.post(post_uri, 'change-query(yo)+reload(seq 100)+change-prompt:hundred> ', headers)
+      assert_equal '401', res.code
+      assert_equal 'Unauthorized', res.message
+      assert_equal "invalid api key\n", res.body
+    end
+    # Valid API Key
+    [{ 'x-api-key' => '123abc' }, { 'X-API-Key' => '123abc' }].each do |headers|
+      res = Net::HTTP.post(post_uri, 'change-query(yo)+reload(seq 100)+change-prompt:hundred> ', headers)
+      assert_equal '200', res.code
+      tmux.until { |lines| assert_equal 100, lines.item_count }
+      tmux.until { |lines| assert_equal 'hundred> yo', lines[-1] }
+    end
+  end
+end
diff --git a/test/test_shell_integration.rb b/test/test_shell_integration.rb
new file mode 100644
index 00000000..c3966479
--- /dev/null
+++ b/test/test_shell_integration.rb
@@ -0,0 +1,485 @@
+# frozen_string_literal: true
+
+require_relative 'lib/common'
+
+# Testing shell integration
+module TestShell
+  attr_reader :tmux
+
+  def setup
+    @tmux = Tmux.new(shell)
+    tmux.prepare
+  end
+
+  def teardown
+    @tmux.kill
+  end
+
+  def set_var(name, val)
+    tmux.prepare
+    tmux.send_keys "export #{name}='#{val}'", :Enter
+    tmux.prepare
+  end
+
+  def unset_var(name)
+    tmux.prepare
+    tmux.send_keys "unset #{name}", :Enter
+    tmux.prepare
+  end
+
+  def test_ctrl_t
+    set_var('FZF_CTRL_T_COMMAND', 'seq 100')
+
+    tmux.prepare
+    tmux.send_keys 'C-t'
+    tmux.until { |lines| assert_equal 100, lines.item_count }
+    tmux.send_keys :Tab, :Tab, :Tab
+    tmux.until { |lines| assert lines.any_include?(' (3)') }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert lines.any_include?('1 2 3') }
+    tmux.send_keys 'C-c'
+  end
+
+  def test_ctrl_t_unicode
+    writelines(['fzf-unicode 테스트1', 'fzf-unicode 테스트2'])
+    set_var('FZF_CTRL_T_COMMAND', "cat #{tempname}")
+
+    tmux.prepare
+    tmux.send_keys 'echo ', 'C-t'
+    tmux.until { |lines| assert_equal 2, lines.item_count }
+    tmux.send_keys 'fzf-unicode'
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+
+    tmux.send_keys '1'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal 1, lines.select_count }
+
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+
+    tmux.send_keys '2'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal 2, lines.select_count }
+
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_match(/echo .*fzf-unicode.*1.* .*fzf-unicode.*2/, lines.join) }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal 'fzf-unicode 테스트1 fzf-unicode 테스트2', lines[-1] }
+  end
+
+  def test_alt_c
+    tmux.prepare
+    tmux.send_keys :Escape, :c
+    lines = tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    expected = lines.reverse.find { |l| l.start_with?('> ') }[2..]
+    tmux.send_keys :Enter
+    tmux.prepare
+    tmux.send_keys :pwd, :Enter
+    tmux.until { |lines| assert lines[-1]&.end_with?(expected) }
+  end
+
+  def test_alt_c_command
+    set_var('FZF_ALT_C_COMMAND', 'echo /tmp')
+
+    tmux.prepare
+    tmux.send_keys 'cd /', :Enter
+
+    tmux.prepare
+    tmux.send_keys :Escape, :c
+    tmux.until { |lines| assert_equal 1, lines.item_count }
+    tmux.send_keys :Enter
+
+    tmux.prepare
+    tmux.send_keys :pwd, :Enter
+    tmux.until { |lines| assert_equal '/tmp', lines[-1] }
+  end
+
+  def test_ctrl_r
+    tmux.prepare
+    tmux.send_keys 'echo 1st', :Enter
+    tmux.prepare
+    tmux.send_keys 'echo 2nd', :Enter
+    tmux.prepare
+    tmux.send_keys 'echo 3d', :Enter
+    tmux.prepare
+    3.times do
+      tmux.send_keys 'echo 3rd', :Enter
+      tmux.prepare
+    end
+    tmux.send_keys 'echo 4th', :Enter
+    tmux.prepare
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys 'e3d'
+    # Duplicates removed: 3d (1) + 3rd (1) => 2 matches
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+    tmux.until { |lines| assert lines[-3]&.end_with?(' echo 3d') }
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| assert lines[-3]&.end_with?(' echo 3rd') }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal 'echo 3rd', lines[-1] }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal '3rd', lines[-1] }
+  end
+
+  def test_ctrl_r_multiline
+    # NOTE: Current bash implementation shows an extra new line if there's
+    # only entry in the history
+    tmux.send_keys ':', :Enter
+    tmux.send_keys 'echo "foo', :Enter, 'bar"', :Enter
+    tmux.until { |lines| assert_equal %w[foo bar], lines[-2..] }
+    tmux.prepare
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| assert_equal '>', lines[-1] }
+    tmux.send_keys 'foo bar'
+    tmux.until { |lines| assert_includes lines[-4], '"foo' } unless shell == :zsh
+    tmux.until { |lines| assert lines[-3]&.match?(/bar"␊?/) }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert lines[-1]&.match?(/bar"␊?/) }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal %w[foo bar], lines[-2..] }
+  end
+
+  def test_ctrl_r_abort
+    skip("doesn't restore the original line when search is aborted pre Bash 4") if shell == :bash && `#{Shell.bash} --version`[/(?<= version )\d+/].to_i < 4
+    %w[foo ' "].each do |query|
+      tmux.prepare
+      tmux.send_keys :Enter, query
+      tmux.until { |lines| assert lines[-1]&.start_with?(query) }
+      tmux.send_keys 'C-r'
+      tmux.until { |lines| assert_equal "> #{query}", lines[-1] }
+      tmux.send_keys 'C-g'
+      tmux.until { |lines| assert lines[-1]&.start_with?(query) }
+    end
+  end
+end
+
+module CompletionTest
+  def test_file_completion
+    FileUtils.mkdir_p('/tmp/fzf-test')
+    FileUtils.mkdir_p('/tmp/fzf test')
+    (1..100).each { |i| FileUtils.touch("/tmp/fzf-test/#{i}") }
+    ['no~such~user', '/tmp/fzf test/foobar'].each do |f|
+      FileUtils.touch(File.expand_path(f))
+    end
+    tmux.prepare
+    tmux.send_keys 'cat /tmp/fzf-test/10**', :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys ' !d'
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+    tmux.send_keys :Tab, :Tab
+    tmux.until { |lines| assert_equal 2, lines.select_count }
+    tmux.send_keys :Enter
+    tmux.until(true) do |lines|
+      assert_equal 'cat /tmp/fzf-test/10 /tmp/fzf-test/100', lines[-1]
+    end
+
+    # ~USERNAME**<TAB>
+    user = `whoami`.chomp
+    tmux.send_keys 'C-u'
+    tmux.send_keys "cat ~#{user}**", :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys "/#{user}"
+    tmux.until { |lines| assert(lines.any? { |l| l.end_with?("/#{user}") }) }
+    tmux.send_keys :Enter
+    tmux.until(true) do |lines|
+      assert_match %r{cat .*/#{user}}, lines[-1]
+    end
+
+    # ~INVALID_USERNAME**<TAB>
+    tmux.send_keys 'C-u'
+    tmux.send_keys 'cat ~such**', :Tab
+    tmux.until(true) { |lines| assert lines.any_include?('no~such~user') }
+    tmux.send_keys :Enter
+    tmux.until(true) { |lines| assert_equal 'cat no~such~user', lines[-1] }
+
+    # /tmp/fzf\ test**<TAB>
+    tmux.send_keys 'C-u'
+    tmux.send_keys 'cat /tmp/fzf\ test/**', :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys 'foobar$'
+    tmux.until do |lines|
+      assert_equal 1, lines.match_count
+      assert lines.any_include?('> /tmp/fzf test/foobar')
+    end
+    tmux.send_keys :Enter
+    tmux.until(true) { |lines| assert_equal 'cat /tmp/fzf\ test/foobar', lines[-1] }
+
+    # Should include hidden files
+    (1..100).each { |i| FileUtils.touch("/tmp/fzf-test/.hidden-#{i}") }
+    tmux.send_keys 'C-u'
+    tmux.send_keys 'cat /tmp/fzf-test/hidden**', :Tab
+    tmux.until(true) do |lines|
+      assert_equal 100, lines.match_count
+      assert lines.any_include?('/tmp/fzf-test/.hidden-')
+    end
+    tmux.send_keys :Enter
+  ensure
+    ['/tmp/fzf-test', '/tmp/fzf test', '~/.fzf-home', 'no~such~user'].each do |f|
+      FileUtils.rm_rf(File.expand_path(f))
+    end
+  end
+
+  def test_file_completion_root
+    tmux.send_keys 'ls /**', :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys :Enter
+  end
+
+  def test_dir_completion
+    (1..100).each do |idx|
+      FileUtils.mkdir_p("/tmp/fzf-test/d#{idx}")
+    end
+    FileUtils.touch('/tmp/fzf-test/d55/xxx')
+    tmux.prepare
+    tmux.send_keys 'cd /tmp/fzf-test/**', :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys :Tab, :Tab # Tab does not work here
+    tmux.send_keys 55
+    tmux.until do |lines|
+      assert_equal 1, lines.match_count
+      assert_includes lines, '> 55'
+      assert_includes lines, '> /tmp/fzf-test/d55'
+    end
+    tmux.send_keys :Enter
+    tmux.until(true) { |lines| assert_equal 'cd /tmp/fzf-test/d55/', lines[-1] }
+    tmux.send_keys :xx
+    tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55/xx', lines[-1] }
+
+    # Should not match regular files (bash-only)
+    if instance_of?(TestBash)
+      tmux.send_keys :Tab
+      tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55/xx', lines[-1] }
+    end
+
+    # Fail back to plusdirs
+    tmux.send_keys :BSpace, :BSpace, :BSpace
+    tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55', lines[-1] }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55/', lines[-1] }
+  end
+
+  def test_process_completion
+    tmux.send_keys 'sleep 12345 &', :Enter
+    lines = tmux.until { |lines| assert lines[-1]&.start_with?('[1] ') }
+    pid = lines[-1]&.split&.last
+    tmux.prepare
+    tmux.send_keys 'C-L'
+    tmux.send_keys 'kill **', :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys 'sleep12345'
+    tmux.until { |lines| assert lines.any_include?('sleep 12345') }
+    tmux.send_keys :Enter
+    tmux.until(true) { |lines| assert_equal "kill #{pid}", lines[-1] }
+  ensure
+    if pid
+      begin
+        Process.kill('KILL', pid.to_i)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+
+  def test_custom_completion
+    tmux.send_keys '_fzf_compgen_path() { echo "$1"; seq 10; }', :Enter
+    tmux.prepare
+    tmux.send_keys 'ls /tmp/**', :Tab
+    tmux.until { |lines| assert_equal 11, lines.match_count }
+    tmux.send_keys :Tab, :Tab, :Tab
+    tmux.until { |lines| assert_equal 3, lines.select_count }
+    tmux.send_keys :Enter
+    tmux.until(true) { |lines| assert_equal 'ls /tmp 1 2', lines[-1] }
+  end
+
+  def test_unset_completion
+    tmux.send_keys 'export FZFFOOBAR=BAZ', :Enter
+    tmux.prepare
+
+    # Using tmux
+    tmux.send_keys 'unset FZFFOOBR**', :Tab
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal 'unset FZFFOOBAR', lines[-1] }
+    tmux.send_keys 'C-c'
+
+    # FZF_TMUX=1
+    new_shell
+    tmux.focus
+    tmux.send_keys 'unset FZFFOOBR**', :Tab
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal 'unset FZFFOOBAR', lines[-1] }
+  end
+
+  def test_completion_in_command_sequence
+    tmux.send_keys 'export FZFFOOBAR=BAZ', :Enter
+    tmux.prepare
+
+    triggers = ['**', '~~', '++', 'ff', '/']
+    triggers.push('&', '[', ';', '`') if instance_of?(TestZsh)
+
+    triggers.each do |trigger|
+      set_var('FZF_COMPLETION_TRIGGER', trigger)
+      command = "echo foo; QUX=THUD unset FZFFOOBR#{trigger}"
+      tmux.send_keys command.sub(/(;|`)$/, '\\\\\1'), :Tab
+      tmux.until { |lines| assert_equal 1, lines.match_count }
+      tmux.send_keys :Enter
+      tmux.until { |lines| assert_equal 'echo foo; QUX=THUD unset FZFFOOBAR', lines[-1] }
+    end
+  end
+
+  def test_file_completion_unicode
+    FileUtils.mkdir_p('/tmp/fzf-test')
+    tmux.paste "cd /tmp/fzf-test; echo test3 > $'fzf-unicode \\355\\205\\214\\354\\212\\244\\355\\212\\2701'; echo test4 > $'fzf-unicode \\355\\205\\214\\354\\212\\244\\355\\212\\2702'"
+    tmux.prepare
+    tmux.send_keys 'cat fzf-unicode**', :Tab
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+
+    tmux.send_keys '1'
+    tmux.until { |lines| assert_equal 1, lines.match_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal 1, lines.select_count }
+
+    tmux.send_keys :BSpace
+    tmux.until { |lines| assert_equal 2, lines.match_count }
+
+    tmux.send_keys '2'
+    tmux.until { |lines| assert_equal 1, lines.select_count }
+    tmux.send_keys :Tab
+    tmux.until { |lines| assert_equal 2, lines.select_count }
+
+    tmux.send_keys :Enter
+    tmux.until(true) { |lines| assert_match(/cat .*fzf-unicode.*1.* .*fzf-unicode.*2/, lines[-1]) }
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert_equal %w[test3 test4], lines[-2..] }
+  end
+
+  def test_custom_completion_api
+    tmux.send_keys 'eval "_fzf$(declare -f _comprun)"', :Enter
+    %w[f g].each do |command|
+      tmux.prepare
+      tmux.send_keys "#{command} b**", :Tab
+      tmux.until do |lines|
+        assert_equal 2, lines.item_count
+        assert_equal 1, lines.match_count
+        assert lines.any_include?("prompt-#{command}")
+        assert lines.any_include?("preview-#{command}-bar")
+      end
+      tmux.send_keys :Enter
+      tmux.until { |lines| assert_equal "#{command} #{command}barbar", lines[-1] }
+      tmux.send_keys 'C-u'
+    end
+  ensure
+    tmux.prepare
+    tmux.send_keys 'unset -f _fzf_comprun', :Enter
+  end
+
+  def test_ssh_completion
+    (1..5).each { |i| FileUtils.touch("/tmp/fzf-test-ssh-#{i}") }
+
+    tmux.send_keys 'ssh jg@localhost**', :Tab
+    tmux.until do |lines|
+      assert_operator lines.match_count, :>=, 1
+    end
+
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert lines.any_include?('ssh jg@localhost') }
+    tmux.send_keys ' -i /tmp/fzf-test-ssh**', :Tab
+    tmux.until do |lines|
+      assert_operator lines.match_count, :>=, 5
+      assert_equal 0, lines.select_count
+    end
+    tmux.send_keys :Tab, :Tab, :Tab
+    tmux.until do |lines|
+      assert_equal 3, lines.select_count
+    end
+    tmux.send_keys :Enter
+    tmux.until { |lines| assert lines.any_include?('ssh jg@localhost  -i /tmp/fzf-test-ssh-') }
+
+    tmux.send_keys 'localhost**', :Tab
+    tmux.until do |lines|
+      assert_operator lines.match_count, :>=, 1
+    end
+  end
+end
+
+class TestBash < TestBase
+  include TestShell
+  include CompletionTest
+
+  def shell
+    :bash
+  end
+
+  def new_shell
+    tmux.prepare
+    tmux.send_keys "FZF_TMUX=1 #{Shell.bash}", :Enter
+    tmux.prepare
+  end
+
+  def test_dynamic_completion_loader
+    tmux.paste 'touch /tmp/foo; _fzf_completion_loader=1'
+    tmux.paste '_completion_loader() { complete -o default fake; }'
+    tmux.paste 'complete -F _fzf_path_completion -o default -o bashdefault fake'
+    tmux.send_keys 'fake /tmp/foo**', :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+    tmux.send_keys 'C-c'
+
+    tmux.prepare
+    tmux.send_keys 'fake /tmp/foo'
+    tmux.send_keys :Tab, 'C-u'
+
+    tmux.prepare
+    tmux.send_keys 'fake /tmp/foo**', :Tab
+    tmux.until { |lines| assert_operator lines.match_count, :>, 0 }
+  end
+end
+
+class TestZsh < TestBase
+  include TestShell
+  include CompletionTest
+
+  def shell
+    :zsh
+  end
+
+  def new_shell
+    tmux.send_keys "FZF_TMUX=1 #{Shell.zsh}", :Enter
+    tmux.prepare
+  end
+
+  def test_complete_quoted_command
+    tmux.send_keys 'export FZFFOOBAR=BAZ', :Enter
+    ['unset', '\unset', "'unset'"].each do |command|
+      tmux.prepare
+      tmux.send_keys "#{command} FZFFOOBR**", :Tab
+      tmux.until { |lines| assert_equal 1, lines.match_count }
+      tmux.send_keys :Enter
+      tmux.until { |lines| assert_equal "#{command} FZFFOOBAR", lines[-1] }
+      tmux.send_keys 'C-c'
+    end
+  end
+end
+
+class TestFish < TestBase
+  include TestShell
+
+  def shell
+    :fish
+  end
+
+  def new_shell
+    tmux.send_keys 'env FZF_TMUX=1 FZF_DEFAULT_OPTS=--no-scrollbar fish', :Enter
+    tmux.send_keys 'function fish_prompt; end; clear', :Enter
+    tmux.until { |lines| assert_empty lines }
+  end
+
+  def set_var(name, val)
+    tmux.prepare
+    tmux.send_keys "set -g #{name} '#{val}'", :Enter
+    tmux.prepare
+  end
+end
diff --git a/test/fzf.vader b/test/vim/fzf.vader
index 07f0c8de..4cb57887 100644
--- a/test/fzf.vader
+++ b/test/vim/fzf.vader
@@ -13,7 +13,7 @@ Execute (fzf#run with dir option):
 
   execute 'lcd' fnameescape(cwd)
   let result = sort(fzf#run({ 'source': 'git ls-files', 'options': '--filter e', 'dir': g:dir }))
-  AssertEqual ['fzf.vader', 'test_go.rb'], result
+  AssertEqual ['fzf.vader'], result
   AssertEqual 1, haslocaldir()
   AssertEqual getcwd(), cwd
 
@@ -23,8 +23,8 @@ Execute (fzf#run with Funcref command):
     call add(g:ret, a:e)
   endfunction
   let result = sort(fzf#run({ 'source': 'git ls-files', 'sink': function('g:FzfTest'), 'options': '--filter e', 'dir': g:dir }))
-  AssertEqual ['fzf.vader', 'test_go.rb'], result
-  AssertEqual ['fzf.vader', 'test_go.rb'], sort(g:ret)
+  AssertEqual ['fzf.vader'], result
+  AssertEqual ['fzf.vader'], sort(g:ret)
 
 Execute (fzf#run with string source):
   let result = sort(fzf#run({ 'source': 'echo hi', 'options': '-f i' }))
@@ -78,18 +78,18 @@ Execute (fzf#wrap):
 
   let opts = fzf#wrap('foobar')
   Log opts
-  AssertEqual '~40%', opts.down
+  AssertEqual 0.9, opts.window.width
   Assert opts.options =~ '--expect='
   Assert !has_key(opts, 'sink')
   Assert has_key(opts, 'sink*')
 
   let opts = fzf#wrap('foobar', {}, 0)
   Log opts
-  AssertEqual '~40%', opts.down
+  AssertEqual 0.9, opts.window.width
 
   let opts = fzf#wrap('foobar', {}, 1)
   Log opts
-  Assert !has_key(opts, 'down')
+  Assert !has_key(opts, 'window')
 
   let opts = fzf#wrap('foobar', {'down': '50%'})
   Log opts
@@ -148,7 +148,7 @@ Execute (fzf#wrap):
 
   let g:fzf_colors = { 'fg': ['fg', 'Error'] }
   let opts = fzf#wrap({})
-  Assert opts.options =~ '^--color=fg:'
+  Assert opts.options =~ '--color=fg:'
 
 Execute (fzf#shellescape with sh):
   AssertEqual '''''', fzf#shellescape('', 'sh')