class TestGoFZF

Public Instance Methods

setup() click to toggle source
Calls superclass method
# File lib/helpers/fzf/test/test_go.rb, line 214
def setup
  super
  @tmux = Tmux.new
end
teardown() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 219
def teardown
  @tmux.kill
end
test_accept_non_empty() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1576
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], readonce.lines(chomp: true)
end
test_accept_non_empty_with_empty_list() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1604
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], readonce.lines(chomp: true)
end
test_accept_non_empty_with_multi_selection() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1592
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], readonce.lines(chomp: true)
end
test_backward_delete_char_eof() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1747
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
test_backward_eof() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1778
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
test_bind() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 803
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], readonce.lines(chomp: true)
end
test_bind_print_query() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 810
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], readonce.lines(chomp: true)
end
test_bind_replace_query() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 817
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
test_cancel() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1211
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
test_change_first_last() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1558
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
test_change_prompt() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1854
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
test_clear_list_when_header_lines_changed_due_to_reload() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1719
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
test_clear_query() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1726
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
test_clear_selection() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1736
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
test_close() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1881
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
test_cycle() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1065
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
test_default_extended() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1326
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
test_disabled() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1662
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
test_escaped_meta_characters() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1622
def test_escaped_meta_characters
  input = [
    'foo^bar',
    'foo$bar',
    'foo!bar',
    "foo'bar",
    'foo bar',
    'bar foo'
  ]
  writelines(tempname, 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
test_exact() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1331
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
test_execute() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 929
def test_execute
  output = '/tmp/fzf-test-execute'
  opts = %[--bind "alt-a:execute(echo /{}/ >> #{output}),alt-b:execute[echo /{}{}/ >> #{output}],C:execute:echo /{}{}{}/ >> #{output}"]
  writelines(tempname, %w[foo'bar foo"bar foo$bar])
  tmux.send_keys "cat #{tempname} | #{fzf(opts)}", :Enter
  tmux.until { |lines| assert_equal '  3/3', lines[-2] }
  tmux.send_keys :Escape, :a
  tmux.send_keys :Escape, :a
  tmux.send_keys :Up
  tmux.send_keys :Escape, :b
  tmux.send_keys :Escape, :b
  tmux.send_keys :Up
  tmux.send_keys :C
  tmux.send_keys 'barfoo'
  tmux.until { |lines| assert_equal '  0/3', lines[-2] }
  tmux.send_keys :Escape, :a
  tmux.send_keys :Escape, :b
  wait do
    assert_path_exists output
    assert_equal %w[
      /foo'bar/ /foo'bar/
      /foo"barfoo"bar/ /foo"barfoo"bar/
      /foo$barfoo$barfoo$bar/
    ], File.readlines(output, chomp: true)
  end
ensure
  begin
    File.unlink(output)
  rescue StandardError
    nil
  end
end
test_execute_multi() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 962
def test_execute_multi
  output = '/tmp/fzf-test-execute-multi'
  opts = %[--multi --bind "alt-a:execute-multi(echo {}/{+} >> #{output})"]
  writelines(tempname, %w[foo'bar foo"bar foo$bar foobar])
  tmux.send_keys "cat #{tempname} | #{fzf(opts)}", :Enter
  tmux.until { |lines| assert_equal '  4/4 (0)', lines[-2] }
  tmux.send_keys :Escape, :a
  tmux.send_keys :BTab, :BTab, :BTab
  tmux.until { |lines| assert_equal '  4/4 (3)', lines[-2] }
  tmux.send_keys :Escape, :a
  tmux.send_keys :Tab, :Tab
  tmux.until { |lines| assert_equal '  4/4 (3)', lines[-2] }
  tmux.send_keys :Escape, :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
  begin
    File.unlink(output)
  rescue StandardError
    nil
  end
end
test_execute_plus_flag() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 991
def test_execute_plus_flag
  output = tempname + '.tmp'
  begin
    File.unlink(output)
  rescue StandardError
    nil
  end
  writelines(tempname, ['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
  begin
    File.unlink(output)
  rescue StandardError
    nil
  end
end
test_execute_shell() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1037
def test_execute_shell
  # Custom script to use as $SHELL
  output = tempname + '.out'
  begin
    File.unlink(output)
  rescue StandardError
    nil
  end
  writelines(tempname,
             ['#!/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
  begin
    File.unlink(output)
  rescue StandardError
    nil
  end
end
test_exit_0() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 463
def test_exit_0
  tmux.send_keys "seq 1 100 | #{fzf(:with_nth, '..,..', :print_query, :q, 555_555, :'0')}", :Enter
  assert_equal %w[555555], readonce.lines(chomp: true)
end
test_exit_0_exit_code() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1295
def test_exit_0_exit_code
  `echo foo | #{FZF} -q bar -0`
  assert_equal 1, $CHILD_STATUS.exitstatus
end
test_exitstatus_empty() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1317
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
test_expect() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 530
def test_expect
  test = lambda do |key, feed, expected = key|
    tmux.send_keys "seq 1 100 | #{fzf(:expect, 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'], readonce.lines(chomp: true)
  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
test_expect_print_query() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 555
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], readonce.lines(chomp: true)
end
test_expect_print_query_select_1() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 573
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'], readonce.lines(chomp: true)
end
test_expect_printable_character_print_query() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 564
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], readonce.lines(chomp: true)
end
test_file_word() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 327
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
test_filter_exitstatus() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1306
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
test_fzf_default_command() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 248
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', readonce.chomp
end
test_fzf_default_command_failure() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 256
def test_fzf_default_command_failure
  tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', 'FZF_DEFAULT_COMMAND=false'), :Enter
  tmux.until { |lines| assert_equal '  [Command failed: false]', lines[-2] }
  tmux.send_keys :Enter
end
test_header() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1151
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
test_header_and_header_lines() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1181
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
test_header_and_header_lines_reverse() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1191
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
test_header_and_header_lines_reverse_list() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1201
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
test_header_first() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2113
  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
test_header_first_reverse() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2130
  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
test_header_lines() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1084
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', readonce.chomp
end
test_header_lines_overflow() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1129
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 '', readonce.chomp
end
test_header_lines_reverse() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1099
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', readonce.chomp
end
test_header_lines_reverse_list() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1114
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', readonce.chomp
end
test_header_lines_with_nth() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1139
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', readonce.chomp
end
test_header_reverse() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1161
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
test_header_reverse_list() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1171
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
test_history() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 872
def test_history
  history_file = '/tmp/fzf-test-history'

  # History with limited number of entries
  begin
    File.unlink(history_file)
  rescue StandardError
    nil
  end
  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..-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
  File.unlink(history_file)
end
test_hscroll_off() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1343
def test_hscroll_off
  writelines(tempname, ['=' * 10_000 + '0123456789'])
  [0, 3, 6].each do |off|
    tmux.prepare
    tmux.send_keys "#{FZF} --hscroll-off=#{off} -q 0 < #{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 :Enter
  end
end
test_info_hidden() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1553
def test_info_hidden
  tmux.send_keys 'seq 10 | fzf --info=hidden', :Enter
  tmux.until { |lines| assert_equal '> 1', lines[-2] }
end
test_interrupt_execute() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1915
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
test_invalid_cache() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 757
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
test_invalid_cache_query_type() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 767
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
test_invalid_option() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1300
def test_invalid_option
  lines = `#{FZF} --foobar 2>&1`
  assert_equal 2, $CHILD_STATUS.exitstatus
  assert_includes lines, 'unknown option: --foobar'
end
test_inverse_only_search_should_not_sort_the_result() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1640
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
test_item_index_reset_on_reload() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2057
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
test_jump() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1365
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], readonce.lines(chomp: true)
end
test_jump_accept() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1393
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', readonce.chomp
end
test_keep_right() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1773
def test_keep_right
  tmux.send_keys "seq 10000 | #{FZF} --read0 --keep-right", :Enter
  tmux.until { |lines| assert lines.any_include?('9999 10000') }
end
test_key_bindings() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 262
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
test_kill_default_command_on_abort() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1926
def test_kill_default_command_on_abort
  script = tempname + '.sh'
  writelines(script,
             ['#!/usr/bin/env bash',
              "echo 'Started'",
              'while :; do sleep 1; done'])
  system("chmod +x #{script}")

  tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND=#{script}"), :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 #{script}") }
ensure
  system("pkill -9 -f #{script}")
  begin
    File.unlink(script)
  rescue StandardError
    nil
  end
end
test_kill_default_command_on_accept() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1949
def test_kill_default_command_on_accept
  script = tempname + '.sh'
  writelines(script,
             ['#!/usr/bin/env bash',
              "echo 'Started'",
              'while :; do sleep 1; done'])
  system("chmod +x #{script}")

  tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND=#{script}"), :Enter
  tmux.until { |lines| assert_equal 1, lines.item_count }
  tmux.send_keys :Enter
  assert_equal 'Started', readonce.chomp
  wait { refute system("pgrep -f #{script}") }
ensure
  system("pkill -9 -f #{script}")
  begin
    File.unlink(script)
  rescue StandardError
    nil
  end
end
test_kill_reload_command_on_abort() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1971
def test_kill_reload_command_on_abort
  script = tempname + '.sh'
  writelines(script,
             ['#!/usr/bin/env bash',
              "echo 'Started'",
              'while :; do sleep 1; done'])
  system("chmod +x #{script}")

  tmux.send_keys "seq 1 3 | #{fzf("--bind 'ctrl-r:reload(#{script})'")}", :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 #{script}") }
ensure
  system("pkill -9 -f #{script}")
  begin
    File.unlink(script)
  rescue StandardError
    nil
  end
end
test_kill_reload_command_on_accept() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1996
def test_kill_reload_command_on_accept
  script = tempname + '.sh'
  writelines(script,
             ['#!/usr/bin/env bash',
              "echo 'Started'",
              'while :; do sleep 1; done'])
  system("chmod +x #{script}")

  tmux.send_keys "seq 1 3 | #{fzf("--bind 'ctrl-r:reload(#{script})'")}", :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', readonce.chomp
  wait { refute system("pgrep -f #{script}") }
ensure
  system("pkill -9 -f #{script}")
  begin
    File.unlink(script)
  rescue StandardError
    nil
  end
end
test_long_line() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 826
def test_long_line
  data = '.' * 256 * 1024
  File.open(tempname, 'w') do |f|
    f << data
  end
  assert_equal data, `#{FZF} -f . < #{tempname}`.chomp
end
test_margin() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1227
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
test_margin_reverse() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1236
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
test_margin_reverse_list() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1242
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
test_marker() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1420
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
test_multi_max() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 352
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
test_multi_order() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 340
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], readonce.lines(chomp: true)
end
test_no_clear() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1541
def test_no_clear
  tmux.send_keys "seq 10 | fzf --no-clear --inline-info --height 5 > #{tempname}", :Enter
  prompt = '>   < 10/10'
  tmux.until { |lines| assert_equal prompt, lines[-1] }
  tmux.send_keys :Enter
  wait do
    assert_path_exists tempname
    assert_equal %w[1], File.readlines(tempname, chomp: true)
  end
  tmux.until { |lines| assert_equal prompt, lines[-1] }
end
test_normalized_match() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1840
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
test_or_operator() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1337
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
test_partial_caching() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1355
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
test_pointer() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1402
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
test_pointer_with_jump() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1408
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
test_preview() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1428
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
test_preview_bindings_with_default_preview() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1789
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
test_preview_bindings_without_default_preview() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1803
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
test_preview_clear_screen() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1848
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
test_preview_correct_tab_width_after_ansi_reset_code() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1656
def test_preview_correct_tab_width_after_ansi_reset_code
  writelines(tempname, ["\x1b[31m+\x1b[m\t\x1b[32mgreen"])
  tmux.send_keys "#{FZF} --preview 'cat #{tempname}'", :Enter
  tmux.until { |lines| assert_includes lines[1], ' +       green ' }
end
test_preview_file() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1516
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
test_preview_flags() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1497
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
test_preview_header() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2020
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
test_preview_hidden() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1456
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
test_preview_q_no_match() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1525
def test_preview_q_no_match
  tmux.send_keys %(: | #{FZF} --preview 'echo foo {q}'), :Enter
  tmux.until { |lines| assert_equal 0, lines.match_count }
  tmux.until { |lines| refute_includes lines[1], ' foo ' }
  tmux.send_keys 'bar'
  tmux.until { |lines| assert_includes lines[1], ' foo bar ' }
  tmux.send_keys 'C-u'
  tmux.until { |lines| refute_includes lines[1], ' foo ' }
end
test_preview_q_no_match_with_initial_query() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1535
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
test_preview_scroll_begin_and_offset() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1831
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
test_preview_scroll_begin_constant() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1819
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
test_preview_scroll_begin_expr() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1825
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
test_preview_size_0() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1467
def test_preview_size_0
  begin
    File.unlink(tempname)
  rescue StandardError
    nil
  end
  tmux.send_keys %(seq 100 | #{FZF} --reverse --preview 'echo {} >> #{tempname}; echo ' --preview-window 0), :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 :Down
  tmux.until { |lines| assert_equal '> 2', lines[3] }
  wait do
    assert_path_exists tempname
    assert_equal %w[1 2], File.readlines(tempname, chomp: true)
  end
  tmux.send_keys :Down
  tmux.until { |lines| assert_equal '> 3', lines[4] }
  wait do
    assert_path_exists tempname
    assert_equal %w[1 2 3], File.readlines(tempname, chomp: true)
  end
end
test_preview_update_on_select() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1612
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
test_preview_window_follow() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1863
def test_preview_window_follow
  tmux.send_keys "#{FZF} --preview 'seq 1000 | nl' --preview-window down:noborder:follow", :Enter
  tmux.until { |lines| assert_equal '1000  1000', lines[-1].strip }
end
test_query_unicode() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 479
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[가나다], readonce.lines(chomp: true)
end
test_read0() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 834
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
test_reload() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1693
def test_reload
  tmux.send_keys %(seq 1000 | #{FZF} --bind 'change:reload(seq {q}),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
test_reload_even_when_theres_no_match() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1712
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
test_reload_should_update_preview() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2073
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
test_scroll() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 447
def test_scroll
  [true, false].each do |rev|
    tmux.send_keys "seq 1 100 | #{fzf(rev && :reverse)}", :Enter
    tmux.until { |lines| assert_includes lines, '  100/100' }
    tmux.send_keys(*Array.new(110) { rev ? :Down : :Up })
    tmux.until { |lines| assert_includes lines, '> 100' }
    tmux.send_keys :Enter
    assert_equal '100', readonce.chomp
  end
end
test_scroll_off() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2080
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
test_scroll_off_large() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2099
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
test_select_1() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 458
def test_select_1
  tmux.send_keys "seq 1 100 | #{fzf(:with_nth, '..,..', :print_query, :q, 5555, :'1')}", :Enter
  assert_equal %w[5555 55], readonce.lines(chomp: true)
end
test_select_1_exit_0_fail() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 468
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], readonce.lines(chomp: true)
  end
end
test_select_all_deselect_all_toggle_all() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 842
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],
               readonce.lines(chomp: true)
end
test_select_deselect() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1894
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
test_smart_case_for_each_term() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 799
def test_smart_case_for_each_term
  assert_equal 1, `echo Foo bar | #{FZF} -x -f "foo Fbar" | wc -l`.to_i
end
test_strip_xterm_osc_sequence() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1760
def test_strip_xterm_osc_sequence
  %W[\x07 \x1b\\].each do |esc|
    writelines(tempname, [%(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
test_sync() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 486
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], readonce.lines(chomp: true)
end
test_tabstop() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1251
def test_tabstop
  writelines(tempname, %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
test_tac() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 499
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], readonce.lines(chomp: true)
end
test_tac_nosort() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 519
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], readonce.lines(chomp: true)
end
test_tac_sort() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 508
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], readonce.lines(chomp: true)
end
test_tiebreak() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 599
def test_tiebreak
  input = %w[
    --foobar--------
    -----foobar---
    ----foobar--
    -------foobar-
  ]
  writelines(tempname, 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
test_tiebreak_begin_algo_v2() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 687
def test_tiebreak_begin_algo_v2
  writelines(tempname, [
               '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
test_tiebreak_end() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 698
def test_tiebreak_end
  writelines(tempname, [
               '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)
end
test_tiebreak_index_begin() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 638
def test_tiebreak_index_begin
  writelines(tempname, [
               '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
test_tiebreak_length_with_nth() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 736
def test_tiebreak_length_with_nth
  input = %w[
    1:hell
    123:hello
    12345:he
    1234567:h
  ]
  writelines(tempname, 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
test_toggle_preview_wrap() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1868
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
test_toggle_sort() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 578
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], readonce.lines(chomp: true)
  end
end
test_unbind() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 2046
def test_unbind
  tmux.send_keys "seq 100 | #{FZF} --bind 'c:clear-query,d:unbind(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] }
end
test_unicode_case() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 593
def test_unicode_case
  writelines(tempname, %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
test_vanilla() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 223
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', readonce.chomp
end
test_with_nth() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 419
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/'], readonce.lines(chomp: true)
    else
      tmux.send_keys '^', '3'
      tmux.until { |lines| assert_equal '  1/2', lines[-2] }
      tmux.send_keys :Enter
      assert_equal ['  1st 2nd 3rd/'], readonce.lines(chomp: true)
    end
  end
end
test_with_nth_ansi() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1280
def test_with_nth_ansi
  writelines(tempname, ["\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
test_with_nth_basic() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1273
def test_with_nth_basic
  writelines(tempname, ['hello world ', 'byebye'])
  assert_equal \
    'hello world ',
    `#{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 < #{tempname}`.chomp
end
test_with_nth_no_ansi() click to toggle source
# File lib/helpers/fzf/test/test_go.rb, line 1287
def test_with_nth_no_ansi
  src = "\x1b[33mhello \x1b[34;1mworld\x1b[m "
  writelines(tempname, [src, 'byebye'])
  assert_equal \
    src,
    `#{FZF} -fhehe -x -n 2.. --with-nth 2,1,1 --no-ansi < #{tempname}`.chomp
end