diff options
| author | Jack Bates <jack@nottheoilrig.com> | 2020-04-20 18:12:00 -0700 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2020-04-21 10:12:00 +0900 |
| commit | a6d3e3687ba2ee26266400db6c77a07bc4ff8fca (patch) | |
| tree | 4c463bdbef87971a1b3273fde98bce9692f2c9ae | |
| parent | 08c2bcb952a0abbead263dcb0026eab58e736e1d (diff) | |
| download | fzf-a6d3e3687ba2ee26266400db6c77a07bc4ff8fca.tar.gz | |
Improve error messages (#1962)
* Add RuboCop Minitest extension
* Improve error messages
* Use chomp option
| -rw-r--r-- | .travis.yml | 4 | ||||
| -rwxr-xr-x | test/test_go.rb | 1002 |
2 files changed, 527 insertions, 479 deletions
diff --git a/.travis.yml b/.travis.yml index 30dde4c8..8c575017 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,11 +16,11 @@ addons: - fish - tmux update: true -install: gem install rubocop rubocop-performance +install: gem install minitest rubocop rubocop-minitest rubocop-performance script: - make test # LC_ALL=C to avoid escape codes in # printf %q $'\355\205\214\354\212\244\355\212\270' on macOS. Bash on # macOS is built without HANDLE_MULTIBYTE? - make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose - - rubocop --require rubocop-performance + - rubocop --require rubocop-minitest --require rubocop-performance diff --git a/test/test_go.rb b/test/test_go.rb index 6f600620..e7a7dd62 100755 --- a/test/test_go.rb +++ b/test/test_go.rb @@ -23,28 +23,16 @@ BASE = File.expand_path('..', __dir__) Dir.chdir(BASE) FZF = "FZF_DEFAULT_OPTS= FZF_DEFAULT_COMMAND= #{BASE}/bin/fzf" -class NilClass - def include?(_str) - false - end - - def start_with?(_str) - false - end - - def end_with?(_str) - false - end -end - def wait since = Time.now - while Time.now - since < DEFAULT_TIMEOUT - return if yield + begin + yield + rescue Minitest::Assertion + raise if Time.now - since > DEFAULT_TIMEOUT sleep(0.05) + retry end - raise 'timeout' end class Shell @@ -89,7 +77,7 @@ class Tmux return unless shell == :fish send_keys 'function fish_prompt; end; clear', :Enter - self.until(&:empty?) + self.until { |lines| raise Minitest::Assertion unless lines.empty? } end def kill @@ -146,7 +134,7 @@ class Tmux send_keys 'C-l' if refresh && !ok end end - rescue StandardError + rescue Minitest::Assertion puts $ERROR_INFO.backtrace puts '>' * 80 puts lines @@ -160,10 +148,10 @@ class Tmux tries = 0 begin self.until do |lines| - send_keys ' ', 'C-u', 'hello', :Left, :Right - lines[-1].end_with?('hello') + send_keys ' ', 'C-u', :Enter, 'hello', :Left, :Right + raise Minitest::Assertion unless lines[-1] == 'hello' end - rescue StandardError + rescue Minitest::Assertion (tries += 1) < 5 ? retry : raise end send_keys 'C-u' @@ -184,17 +172,17 @@ class TestBase < Minitest::Test def tempname @temp_suffix ||= 0 [TEMPNAME, - caller_locations.map(&:label).find { |l| l =~ /^test_/ }, + caller_locations.map(&:label).find { |l| l.start_with?('test_') }, @temp_suffix].join('-') end def writelines(path, lines) File.unlink(path) while File.exist?(path) - File.open(path, 'w') { |f| f << lines.join($INPUT_RECORD_SEPARATOR) + $INPUT_RECORD_SEPARATOR } + File.open(path, 'w') { |f| f.puts lines } end def readonce - wait { File.exist?(tempname) } + wait { assert_path_exists tempname } File.read(tempname) ensure File.unlink(tempname) while File.exist?(tempname) @@ -232,7 +220,10 @@ class TestGoFZF < TestBase def test_vanilla tmux.send_keys "seq 1 100000 | #{fzf}", :Enter - tmux.until { |lines| lines.last =~ /^>/ && lines[-2] =~ /^ 100000/ } + 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] @@ -242,10 +233,10 @@ class TestGoFZF < TestBase # 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| - lines[-4] == '> 3910' && - lines[-3] == ' 391' && - lines[-2] == ' 856/100000' && - lines[-1] == '> 391' + 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 @@ -254,7 +245,7 @@ class TestGoFZF < TestBase def test_fzf_default_command tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND='echo hello'"), :Enter - tmux.until { |lines| lines[-3] == '> hello' } + tmux.until { |lines| assert_equal '> hello', lines[-3] } tmux.send_keys :Enter assert_equal 'hello', readonce.chomp @@ -262,78 +253,78 @@ class TestGoFZF < TestBase def test_fzf_default_command_failure tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', 'FZF_DEFAULT_COMMAND=false'), :Enter - tmux.until { |lines| lines[-2].include?('Command failed: false') } + tmux.until { |lines| assert_equal ' [Command failed: false]', lines[-2] } tmux.send_keys :Enter end def test_key_bindings tmux.send_keys "#{FZF} -q 'foo bar foo-bar'", :Enter - tmux.until { |lines| lines.last =~ /^>/ } + tmux.until { |lines| assert_equal '> foo bar foo-bar', lines.last } # CTRL-A tmux.send_keys 'C-A', '(' - tmux.until { |lines| lines.last == '> (foo bar foo-bar' } + tmux.until { |lines| assert_equal '> (foo bar foo-bar', lines.last } # META-F tmux.send_keys :Escape, :f, ')' - tmux.until { |lines| lines.last == '> (foo) bar foo-bar' } + tmux.until { |lines| assert_equal '> (foo) bar foo-bar', lines.last } # CTRL-B tmux.send_keys 'C-B', 'var' - tmux.until { |lines| lines.last == '> (foovar) bar foo-bar' } + tmux.until { |lines| assert_equal '> (foovar) bar foo-bar', lines.last } # Left, CTRL-D tmux.send_keys :Left, :Left, 'C-D' - tmux.until { |lines| lines.last == '> (foovr) bar foo-bar' } + tmux.until { |lines| assert_equal '> (foovr) bar foo-bar', lines.last } # META-BS tmux.send_keys :Escape, :BSpace - tmux.until { |lines| lines.last == '> (r) bar foo-bar' } + tmux.until { |lines| assert_equal '> (r) bar foo-bar', lines.last } # CTRL-Y tmux.send_keys 'C-Y', 'C-Y' - tmux.until { |lines| lines.last == '> (foovfoovr) bar foo-bar' } + tmux.until { |lines| assert_equal '> (foovfoovr) bar foo-bar', lines.last } # META-B tmux.send_keys :Escape, :b, :Space, :Space - tmux.until { |lines| lines.last == '> ( foovfoovr) bar foo-bar' } + tmux.until { |lines| assert_equal '> ( foovfoovr) bar foo-bar', lines.last } # CTRL-F / Right tmux.send_keys 'C-F', :Right, '/' - tmux.until { |lines| lines.last == '> ( fo/ovfoovr) bar foo-bar' } + tmux.until { |lines| assert_equal '> ( fo/ovfoovr) bar foo-bar', lines.last } # CTRL-H / BS tmux.send_keys 'C-H', :BSpace - tmux.until { |lines| lines.last == '> ( fovfoovr) bar foo-bar' } + tmux.until { |lines| assert_equal '> ( fovfoovr) bar foo-bar', lines.last } # CTRL-E tmux.send_keys 'C-E', 'baz' - tmux.until { |lines| lines.last == '> ( fovfoovr) bar foo-barbaz' } + tmux.until { |lines| assert_equal '> ( fovfoovr) bar foo-barbaz', lines.last } # CTRL-U tmux.send_keys 'C-U' - tmux.until { |lines| lines.last == '>' } + tmux.until { |lines| assert_equal '>', lines.last } # CTRL-Y tmux.send_keys 'C-Y' - tmux.until { |lines| lines.last == '> ( fovfoovr) bar foo-barbaz' } + tmux.until { |lines| assert_equal '> ( fovfoovr) bar foo-barbaz', lines.last } # CTRL-W tmux.send_keys 'C-W', 'bar-foo' - tmux.until { |lines| lines.last == '> ( fovfoovr) bar 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| lines.last == '> bar( fovfoovr) bar -foo' } + tmux.until { |lines| assert_equal '> bar( fovfoovr) bar -foo', lines.last } # CTRL-M tmux.send_keys 'C-M' - tmux.until { |lines| lines.last !~ /^>/ } + 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| lines.last =~ /^>/ } + tmux.until { |lines| assert_equal '> --/foo bar/foo-bar/baz', lines.last } tmux.send_keys :Escape, :b tmux.send_keys :Escape, :b @@ -341,77 +332,85 @@ class TestGoFZF < TestBase tmux.send_keys :Escape, :d tmux.send_keys :Escape, :f tmux.send_keys :Escape, :BSpace - tmux.until { |lines| lines.last == '> --///baz' } + 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| lines.last =~ /^>/ } + 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| lines[-2].include?('(6)') } + 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.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[3 2 5 6 8 7], readonce.lines(chomp: true) 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| lines.item_count == 10 } + tmux.until { |lines| assert_equal 10, lines.item_count } tmux.send_keys '1' tmux.until do |lines| - lines[1].include?('[1]/1') && lines[-2].include?('2/10') + assert_includes lines[1], ' [1]/1 ' + assert lines[-2]&.start_with?(' 2/10 ') end tmux.send_keys 'A' tmux.until do |lines| - lines[1].include?('[1 10]/1') && lines[-2].include?('2/10 (2/3)') + assert_includes lines[1], ' [1 10]/1 ' + assert lines[-2]&.start_with?(' 2/10 (2/3)') end tmux.send_keys :BSpace - tmux.until { |lines| lines[-2].include?('10/10 (2/3)') } + tmux.until { |lines| assert lines[-2]&.start_with?(' 10/10 (2/3)') } tmux.send_keys 'T' tmux.until do |lines| - lines[1].include?('[2 3 4]/1') && lines[-2].include?('10/10 (3/3)') + 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| - lines[1].include?('[1 5 6]/1') && lines[-2].include?('10/10 (3/3)') + 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| - lines[1].include?('[5 6]/2') && lines[-2].include?('10/10 (2/3)') + 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| - lines[1].include?('[5 6 2]/3') && lines[-2].include?('10/10 (3/3)') + 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| lines[-2].include?('1/10 (3/3)') } + tmux.until { |lines| assert lines[-2]&.start_with?(' 1/10 (3/3)') } tmux.send_keys 'T' tmux.until do |lines| - lines[1].include?('[5 6]/2') && lines[-2].include?('1/10 (2/3)') + assert_includes lines[1], ' [5 6]/2 ' + assert lines[-2]&.start_with?(' 1/10 (2/3)') end tmux.send_keys :BSpace - tmux.until { |lines| lines[-2].include?('10/10 (2/3)') } + tmux.until { |lines| assert lines[-2]&.start_with?(' 10/10 (2/3)') } tmux.send_keys 'A' tmux.until do |lines| - lines[1].include?('[5 6 1]/1') && lines[-2].include?('10/10 (3/3)') + assert_includes lines[1], ' [5 6 1]/1 ' + assert lines[-2]&.start_with?(' 10/10 (3/3)') end end @@ -421,7 +420,7 @@ class TestGoFZF < TestBase echo ' first second third/') | #{fzf(multi && :multi, :x, :nth, 2, :with_nth, '2,-1,1')}", :Enter - tmux.until { |lines| lines[-2].include?('2/2') } + tmux.until { |lines| assert_equal ' 2/2', lines[-2] } # Transformed list lines = tmux.capture @@ -431,14 +430,14 @@ class TestGoFZF < TestBase # However, the output must not be transformed if multi tmux.send_keys :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(2)') } + tmux.until { |lines| assert_equal ' 2/2 (2)', lines[-2] } tmux.send_keys :Enter - assert_equal [' 1st 2nd 3rd/', ' first second third/'], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal [' 1st 2nd 3rd/', ' first second third/'], readonce.lines(chomp: true) else tmux.send_keys '^', '3' - tmux.until { |lines| lines[-2].include?('1/2') } + tmux.until { |lines| assert_equal ' 1/2', lines[-2] } tmux.send_keys :Enter - assert_equal [' 1st 2nd 3rd/'], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal [' 1st 2nd 3rd/'], readonce.lines(chomp: true) end end end @@ -446,9 +445,9 @@ class TestGoFZF < TestBase def test_scroll [true, false].each do |rev| tmux.send_keys "seq 1 100 | #{fzf(rev && :reverse)}", :Enter - tmux.until { |lines| lines.include?(' 100/100') } + tmux.until { |lines| assert_includes lines, ' 100/100' } tmux.send_keys(*Array.new(110) { rev ? :Down : :Up }) - tmux.until { |lines| lines.include?('> 100') } + tmux.until { |lines| assert_includes lines, '> 100' } tmux.send_keys :Enter assert_equal '100', readonce.chomp end @@ -456,85 +455,85 @@ class TestGoFZF < TestBase 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.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[5555 55], readonce.lines(chomp: true) 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], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[555555], readonce.lines(chomp: true) 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| lines.last =~ /^> 5/ } + tmux.until { |lines| assert_equal '> 5', lines.last } tmux.send_keys :BTab, :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(3)') } + tmux.until { |lines| assert_equal ' 19/100 (3)', lines[-2] } tmux.send_keys :Enter - assert_equal %w[5 5 50 51], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[5 5 50 51], readonce.lines(chomp: true) 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| lines[-2].include?('1/2') } + tmux.until { |lines| assert_equal ' 1/2', lines[-2] } tmux.send_keys :Enter - assert_equal %w[가나다], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[가나다], readonce.lines(chomp: true) end def test_sync tmux.send_keys "seq 1 100 | #{fzf!(:multi)} | awk '{print $1 $1}' | #{fzf(:sync)}", :Enter - tmux.until { |lines| lines[-1] == '>' } + tmux.until { |lines| assert_equal '>', lines[-1] } tmux.send_keys 9 - tmux.until { |lines| lines[-2] == ' 19/100' } + tmux.until { |lines| assert_equal ' 19/100', lines[-2] } tmux.send_keys :BTab, :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(3)') } + tmux.until { |lines| assert_equal ' 19/100 (3)', lines[-2] } tmux.send_keys :Enter - tmux.until { |lines| lines[-1] == '>' } + tmux.until { |lines| assert_equal '>', lines[-1] } tmux.send_keys 'C-K', :Enter - assert_equal %w[9090], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[9090], readonce.lines(chomp: true) end def test_tac tmux.send_keys "seq 1 1000 | #{fzf(:tac, :multi)}", :Enter - tmux.until { |lines| lines[-2].include?('1000/1000') } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys :BTab, :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(3)') } + tmux.until { |lines| assert_equal ' 1000/1000 (3)', lines[-2] } tmux.send_keys :Enter - assert_equal %w[1000 999 998], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[1000 999 998], readonce.lines(chomp: true) end def test_tac_sort tmux.send_keys "seq 1 1000 | #{fzf(:tac, :multi)}", :Enter - tmux.until { |lines| lines[-2].include?('1000/1000') } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys '99' - tmux.until { |lines| lines[-2].include?('28/1000') } + tmux.until { |lines| assert_equal ' 28/1000', lines[-2] } tmux.send_keys :BTab, :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(3)') } + tmux.until { |lines| assert_equal ' 28/1000 (3)', lines[-2] } tmux.send_keys :Enter - assert_equal %w[99 999 998], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[99 999 998], readonce.lines(chomp: true) end def test_tac_nosort tmux.send_keys "seq 1 1000 | #{fzf(:tac, :no_sort, :multi)}", :Enter - tmux.until { |lines| lines[-2].include?('1000/1000') } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys '00' - tmux.until { |lines| lines[-2].include?('10/1000') } + tmux.until { |lines| assert_equal ' 10/1000', lines[-2] } tmux.send_keys :BTab, :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(3)') } + tmux.until { |lines| assert_equal ' 10/1000 (3)', lines[-2] } tmux.send_keys :Enter - assert_equal %w[1000 900 800], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[1000 900 800], readonce.lines(chomp: true) end def test_expect test = lambda do |key, feed, expected = key| tmux.send_keys "seq 1 100 | #{fzf(:expect, key)}", :Enter - tmux.until { |lines| lines[-2].include?('100/100') } + tmux.until { |lines| assert_equal ' 100/100', lines[-2] } tmux.send_keys '55' - tmux.until { |lines| lines[-2].include?('1/100') } + tmux.until { |lines| assert_equal ' 1/100', lines[-2] } tmux.send_keys(*feed) tmux.prepare - assert_equal [expected, '55'], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal [expected, '55'], readonce.lines(chomp: true) end test.call('ctrl-t', 'C-T') test.call('ctrl-t', 'Enter', '') @@ -553,46 +552,46 @@ class TestGoFZF < TestBase def test_expect_print_query tmux.send_keys "seq 1 100 | #{fzf('--expect=alt-z', :print_query)}", :Enter - tmux.until { |lines| lines[-2].include?('100/100') } + tmux.until { |lines| assert_equal ' 100/100', lines[-2] } tmux.send_keys '55' - tmux.until { |lines| lines[-2].include?('1/100') } + tmux.until { |lines| assert_equal ' 1/100', lines[-2] } tmux.send_keys :Escape, :z - assert_equal %w[55 alt-z 55], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[55 alt-z 55], readonce.lines(chomp: true) end def test_expect_printable_character_print_query tmux.send_keys "seq 1 100 | #{fzf('--expect=z --print-query')}", :Enter - tmux.until { |lines| lines[-2].include?('100/100') } + tmux.until { |lines| assert_equal ' 100/100', lines[-2] } tmux.send_keys '55' - tmux.until { |lines| lines[-2].include?('1/100') } + tmux.until { |lines| assert_equal ' 1/100', lines[-2] } tmux.send_keys 'z' - assert_equal %w[55 z 55], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[55 z 55], readonce.lines(chomp: true) 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'], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal ['55', '', '55'], readonce.lines(chomp: true) 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| lines[-3].include?('> 111') } + tmux.until { |lines| assert_equal '> 111', lines[-3] } tmux.send_keys :Tab - tmux.until { |lines| lines[-2].include?('4/111 -S (1)') } + tmux.until { |lines| assert_equal ' 4/111 -S (1)', lines[-2] } tmux.send_keys 'C-R' - tmux.until { |lines| lines[-3].include?('> 11') } + tmux.until { |lines| assert_equal '> 11', lines[-3] } tmux.send_keys :Tab - tmux.until { |lines| lines[-2].include?('4/111 +S (2)') } + tmux.until { |lines| assert_equal ' 4/111 +S (2)', lines[-2] } tmux.send_keys :Enter - assert_equal %w[111 11], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[111 11], readonce.lines(chomp: true) end end def test_unicode_case writelines(tempname, %w[строКА1 СТРОКА2 строка3 Строка4]) - assert_equal %w[СТРОКА2 Строка4], `#{FZF} -fС < #{tempname}`.split($INPUT_RECORD_SEPARATOR) - assert_equal %w[строКА1 СТРОКА2 строка3 Строка4], `#{FZF} -fс < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + 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 @@ -604,7 +603,7 @@ class TestGoFZF < TestBase ] writelines(tempname, input) - assert_equal input, `#{FZF} -ffoobar --tiebreak=index < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + assert_equal input, `#{FZF} -ffoobar --tiebreak=index < #{tempname}`.lines(chomp: true) by_length = %w[ ----foobar-- @@ -612,8 +611,8 @@ class TestGoFZF < TestBase -------foobar- --foobar-------- ] - assert_equal by_length, `#{FZF} -ffoobar < #{tempname}`.split($INPUT_RECORD_SEPARATOR) - assert_equal by_length, `#{FZF} -ffoobar --tiebreak=length < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + 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-------- @@ -621,17 +620,17 @@ class TestGoFZF < TestBase -----foobar--- -------foobar- ] - assert_equal by_begin, `#{FZF} -ffoobar --tiebreak=begin < #{tempname}`.split($INPUT_RECORD_SEPARATOR) - assert_equal by_begin, `#{FZF} -f"!z foobar" -x --tiebreak begin < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + 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}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -ffoobar --tiebreak end < #{tempname}`.lines(chomp: true) - assert_equal input, `#{FZF} -f"!z" -x --tiebreak end < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + assert_equal input, `#{FZF} -f"!z" -x --tiebreak end < #{tempname}`.lines(chomp: true) end def test_tiebreak_index_begin @@ -651,7 +650,7 @@ class TestGoFZF < TestBase 'xxoxxxoxx', 'xoxxxxxox', 'xoxxxxxoxx' - ], `#{FZF} -foo < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -foo < #{tempname}`.lines(chomp: true) assert_equal [ 'xxxoxoxxx', @@ -660,7 +659,7 @@ class TestGoFZF < TestBase 'xxoxxxoxx', 'xoxxxxxoxx', 'xoxxxxxox' - ], `#{FZF} -foo --tiebreak=index < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{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 @@ -671,7 +670,7 @@ class TestGoFZF < TestBase 'xxoxxxoxx', 'xoxxxxxoxx', 'xoxxxxxox' - ], `#{FZF} -foo --tiebreak=begin < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -foo --tiebreak=begin < #{tempname}`.lines(chomp: true) assert_equal [ ' xxoxoxxx', @@ -680,7 +679,7 @@ class TestGoFZF < TestBase 'xxoxxxoxx', 'xoxxxxxox', 'xoxxxxxoxx' - ], `#{FZF} -foo --tiebreak=begin,length < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -foo --tiebreak=begin,length < #{tempname}`.lines(chomp: true) end def test_tiebreak_begin_algo_v2 @@ -691,7 +690,7 @@ class TestGoFZF < TestBase assert_equal [ 'foo bar baz', 'baz foo bar' - ], `#{FZF} -fbar --tiebreak=begin --algo=v2 < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -fbar --tiebreak=begin --algo=v2 < #{tempname}`.lines(chomp: true) end def test_tiebreak_end @@ -711,7 +710,7 @@ class TestGoFZF < TestBase 'xoxxxxxxxx', 'xxoxxxxxxx', 'xxxoxxxxxx' - ], `#{FZF} -fo < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -fo < #{tempname}`.lines(chomp: true) assert_equal [ 'xxxxxoxxx', @@ -720,7 +719,7 @@ class TestGoFZF < TestBase 'xxxoxxxxxx', 'xxoxxxxxxx', 'xoxxxxxxxx' - ], `#{FZF} -fo --tiebreak=end < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -fo --tiebreak=end < #{tempname}`.lines(chomp: true) assert_equal [ 'xxxxxoxxx', @@ -729,7 +728,7 @@ class TestGoFZF < TestBase 'xxxoxxxxxx', 'xxoxxxxxxx', 'xoxxxxxxxx' - ], `#{FZF} -fo --tiebreak=end,length,begin < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + ], `#{FZF} -fo --tiebreak=end,length,begin < #{tempname}`.lines(chomp: true) end def test_tiebreak_length_with_nth @@ -747,19 +746,19 @@ class TestGoFZF < TestBase 123:hello 1234567:h ] - assert_equal output, `#{FZF} -fh < #{tempname}`.split($INPUT_RECORD_SEPARATOR) + 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}`.split($INPUT_RECORD_SEPARATOR) + assert_equal output, `#{FZF} -fh -n2 -d: < #{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| lines[-2].include?('2/3') } + tmux.until { |lines| assert_equal ' 2/3', lines[-2] } tmux.send_keys :BSpace - tmux.until { |lines| lines[-2].include?('3/3') } + tmux.until { |lines| assert_equal ' 3/3', lines[-2] } tmux.send_keys :D - tmux.until { |lines| lines[-2].include?('1/3') } + tmux.until { |lines| assert_equal ' 1/3', lines[-2] } tmux.send_keys :Enter end @@ -768,31 +767,31 @@ class TestGoFZF < TestBase # Suffix match tmux.send_keys command, :Enter - tmux.until { |lines| lines.match_count == 104 } + tmux.until { |lines| assert_equal 104, lines.match_count } tmux.send_keys 'foo$' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys 'bar' - tmux.until { |lines| lines.match_count == 1 } + 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| lines.match_count == 104 } + tmux.until { |lines| assert_equal 104, lines.match_count } tmux.send_keys '^bar' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys 'C-a', 'foo' - tmux.until { |lines| lines.match_count == 1 } + 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| lines.match_count == 104 } + tmux.until { |lines| assert_equal 104, lines.match_count } tmux.send_keys "'12" - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys 'C-a', 'foo' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } end def test_smart_case_for_each_term @@ -801,25 +800,25 @@ class TestGoFZF < TestBase 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| lines[-2].end_with?('/1000') } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys 'uuu', 'TTT', 'tt', 'uu', 'ttt', 'C-j' - assert_equal %w[4 5 6 9], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[4 5 6 9], readonce.lines(chomp: true) end def test_bind_print_query tmux.send_keys "seq 1 1000 | #{fzf('-m --bind=ctrl-j:print-query')}", :Enter - tmux.until { |lines| lines[-2].end_with?('/1000') } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys 'print-my-query', 'C-j' - assert_equal %w[print-my-query], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[print-my-query], readonce.lines(chomp: true) 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| lines[-2].end_with?('272/1000') } + tmux.until { |lines| assert_equal ' 272/1000', lines[-2] } tmux.send_keys 'C-k', 'C-j' - tmux.until { |lines| lines[-2].end_with?('29/1000') } - tmux.until { |lines| lines[-1].end_with?('> 10') } + tmux.until { |lines| assert_equal ' 29/1000', lines[-2] } + tmux.until { |lines| assert_equal '> 10', lines[-1] } end def test_long_line @@ -831,7 +830,7 @@ class TestGoFZF < TestBase end def test_read0 - lines = `find .`.split($INPUT_RECORD_SEPARATOR) + lines = `find .`.lines(chomp: true) assert_equal lines.last, `find . | #{FZF} -e -f "^#{lines.last}$"`.chomp assert_equal \ lines.last, @@ -840,32 +839,32 @@ class TestGoFZF < TestBase 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| lines[-2].include?('100/100') } + tmux.until { |lines| assert_equal ' 100/100', lines[-2] } tmux.send_keys :BTab, :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(3)') } + tmux.until { |lines| assert_equal ' 100/100 (3)', lines[-2] } tmux.send_keys 'C-t' - tmux.until { |lines| lines[-2].include?('(97)') } + tmux.until { |lines| assert_equal ' 100/100 (97)', lines[-2] } tmux.send_keys 'C-a' - tmux.until { |lines| lines[-2].include?('(100)') } + tmux.until { |lines| assert_equal ' 100/100 (100)', lines[-2] } tmux.send_keys :Tab, :Tab - tmux.until { |lines| lines[-2].include?('(98)') } + tmux.until { |lines| assert_equal ' 100/100 (98)', lines[-2] } tmux.send_keys '100' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys 'C-d' - tmux.until { |lines| lines[-2].include?('(97)') } + tmux.until { |lines| assert_equal ' 1/100 (97)', lines[-2] } tmux.send_keys 'C-u' - tmux.until { |lines| lines.match_count == 100 } + tmux.until { |lines| assert_equal 100, lines.match_count } tmux.send_keys 'C-d' - tmux.until { |lines| !lines[-2].include?('(') } + tmux.until { |lines| assert_equal ' 100/100', lines[-2] } tmux.send_keys :BTab, :BTab - tmux.until { |lines| lines[-2].include?('(2)') } + tmux.until { |lines| assert_equal ' 100/100 (2)', lines[-2] } tmux.send_keys 0 - tmux.until { |lines| lines[-2].include?('10/100') } + tmux.until { |lines| assert_equal ' 10/100 (2)', lines[-2] } tmux.send_keys 'C-a' - tmux.until { |lines| lines[-2].include?('(12)') } + 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.split($INPUT_RECORD_SEPARATOR) + readonce.lines(chomp: true) end def test_history @@ -878,42 +877,48 @@ class TestGoFZF < TestBase nil end opts = "--history=#{history_file} --history-size=4" - input = %w[00 11 22 33 44].map { |e| e + $INPUT_RECORD_SEPARATOR } + input = %w[00 11 22 33 44] input.each do |keys| tmux.prepare tmux.send_keys "seq 100 | #{fzf(opts)}", :Enter - tmux.until { |lines| lines[-2].include?('100/100') } + tmux.until { |lines| assert_equal ' 100/100', lines[-2] } tmux.send_keys keys - tmux.until { |lines| lines[-2].include?('1/100') } + tmux.until { |lines| assert_equal ' 1/100', lines[-2] } tmux.send_keys :Enter end - wait { File.exist?(history_file) && File.readlines(history_file) == input[1..-1] } + 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| lines[-2].include?('100/100') } + tmux.until { |lines| assert_equal ' 100/100', lines[-2] } tmux.send_keys 'C-p' - tmux.until { |lines| lines[-1].end_with?('> 44') } + tmux.until { |lines| assert_equal '> 44', lines[-1] } tmux.send_keys 'C-p' - tmux.until { |lines| lines[-1].end_with?('> 33') } + tmux.until { |lines| assert_equal '> 33', lines[-1] } tmux.send_keys :BSpace - tmux.until { |lines| lines[-1].end_with?('> 3') } + tmux.until { |lines| assert_equal '> 3', lines[-1] } tmux.send_keys 1 - tmux.until { |lines| lines[-1].end_with?('> 31') } + tmux.until { |lines| assert_equal '> 31', lines[-1] } tmux.send_keys 'C-p' - tmux.until { |lines| lines[-1].end_with?('> 22') } + tmux.until { |lines| assert_equal '> 22', lines[-1] } tmux.send_keys 'C-n' - tmux.until { |lines| lines[-1].end_with?('> 31') } + tmux.until { |lines| assert_equal '> 31', lines[-1] } tmux.send_keys 0 - tmux.until { |lines| lines[-1].end_with?('> 310') } + tmux.until { |lines| assert_equal '> 310', lines[-1] } tmux.send_keys :Enter - wait { File.exist?(history_file) && File.readlines(history_file) == %w[22 33 44 310].map { |e| e + $INPUT_RECORD_SEPARATOR } } + 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| lines[-2].include?('100/100') } + 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| lines[-1].end_with?('33') } + tmux.until { |lines| assert_equal '> 33', lines[-1] } tmux.send_keys :Enter ensure File.unlink(history_file) @@ -924,7 +929,7 @@ class TestGoFZF < TestBase 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| lines[-2] == ' 3/3' } + tmux.until { |lines| assert_equal ' 3/3', lines[-2] } tmux.send_keys :Escape, :a tmux.send_keys :Escape, :a tmux.send_keys :Up @@ -933,15 +938,16 @@ class TestGoFZF < TestBase tmux.send_keys :Up tmux.send_keys :C tmux.send_keys 'barfoo' - tmux.until { |lines| lines[-2] == ' 0/3' } + tmux.until { |lines| assert_equal ' 0/3', lines[-2] } tmux.send_keys :Escape, :a tmux.send_keys :Escape, :b wait do - File.exist?(output) && File.readlines(output).map(&:chomp) == %w[ + 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 @@ -956,20 +962,21 @@ class TestGoFZF < TestBase 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| lines[-2].include?('4/4') } + tmux.until { |lines| assert_equal ' 4/4', lines[-2] } tmux.send_keys :Escape, :a - tmux.until { |lines| lines[-2].include?('/4') } tmux.send_keys :BTab, :BTab, :BTab + tmux.until { |lines| assert_equal ' 4/4 (3)', lines[-2] } tmux.send_keys :Escape, :a - tmux.until { |lines| lines[-2].include?('/4') } tmux.send_keys :Tab, :Tab + tmux.until { |lines| assert_equal ' 4/4 (3)', lines[-2] } tmux.send_keys :Escape, :a wait do - File.exist?(output) && File.readlines(output).map(&:chomp) == [ + 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 @@ -990,29 +997,32 @@ class TestGoFZF < TestBase tmux.send_keys "cat #{tempname} | #{FZF} --multi --bind 'x:execute-silent(echo {+}/{}/{+2}/{2} >> #{output})'", :Enter - execute = lambda do - tmux.send_keys 'x', 'y' - tmux.until { |lines| lines[-2].include?('0/2') } - tmux.send_keys :BSpace - tmux.until { |lines| lines[-2].include?('2/2') } - end - - tmux.until { |lines| lines[-2].include?('2/2') } - execute.call + tmux.until { |lines| assert_equal ' 2/2', lines[-2] } + tmux.send_keys 'xy' + tmux.until { |lines| assert_equal ' 0/2', lines[-2] } + tmux.send_keys :BSpace + tmux.until { |lines| assert_equal ' 2/2', lines[-2] } tmux.send_keys :Up tmux.send_keys :Tab - execute.call + 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 - execute.call + 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 - File.exist?(output) && File.readlines(output).map(&:chomp) == [ + 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 @@ -1035,9 +1045,13 @@ class TestGoFZF < TestBase system("chmod +x #{tempname}") tmux.send_keys "echo foo | SHELL=#{tempname} fzf --bind 'enter:execute:{}bar'", :Enter - tmux.until { |lines| lines[-2].include?('1/1') } + tmux.until { |lines| assert_equal ' 1/1', lines[-2] } tmux.send_keys :Enter - wait { File.exist?(output) && File.readlines(output).map(&:chomp) == ["-c / 'foo'bar"] } + 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) @@ -1048,31 +1062,31 @@ class TestGoFZF < TestBase def test_cycle tmux.send_keys "seq 8 | #{fzf(:cycle)}", :Enter - tmux.until { |lines| lines[-2].include?('8/8') } + tmux.until { |lines| assert_equal ' 8/8', lines[-2] } tmux.send_keys :Down - tmux.until { |lines| lines[-10].start_with?('>') } + tmux.until { |lines| assert_equal '> 8', lines[-10] } tmux.send_keys :Down - tmux.until { |lines| lines[-9].start_with?('>') } + tmux.until { |lines| assert_equal '> 7', lines[-9] } tmux.send_keys :Up - tmux.until { |lines| lines[-10].start_with?('>') } + tmux.until { |lines| assert_equal '> 8', lines[-10] } tmux.send_keys :PgUp - tmux.until { |lines| lines[-10].start_with?('>') } + tmux.until { |lines| assert_equal '> 8', lines[-10] } tmux.send_keys :Up - tmux.until { |lines| lines[-3].start_with?('>') } + tmux.until { |lines| assert_equal '> 1', lines[-3] } tmux.send_keys :PgDn - tmux.until { |lines| lines[-3].start_with?('>') } + tmux.until { |lines| assert_equal '> 1', lines[-3] } tmux.send_keys :Down - tmux.until { |lines| lines[-10].start_with?('>') } + 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| - lines[-2].include?('/90') && - lines[-3] == ' 1' && - lines[-4] == ' 2' && - lines[-13] == '> 50' + 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 @@ -1084,10 +1098,10 @@ class TestGoFZF < TestBase tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5 --reverse')}", :Enter 2.times do tmux.until do |lines| - lines[1].include?('/90') && - lines[2] == ' 1' && - lines[3] == ' 2' && - lines[12] == '> 50' + 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 @@ -1099,10 +1113,10 @@ class TestGoFZF < TestBase tmux.send_keys "seq 100 | #{fzf('--header-lines=10 -q 5 --layout=reverse-list')}", :Enter 2.times do tmux.until do |lines| - lines[0] == '> 50' && - lines[-4] == ' 2' && - lines[-3] == ' 1' && - lines[-2].include?('/90') + 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 @@ -1113,8 +1127,8 @@ class TestGoFZF < TestBase def test_header_lines_overflow tmux.send_keys "seq 100 | #{fzf('--header-lines=200')}", :Enter tmux.until do |lines| - lines[-2].include?('0/0') && - lines[-3].include?(' 1') + assert_equal ' 0/0', lines[-2] + assert_equal ' 1', lines[-3] end tmux.send_keys :Enter assert_equal '', readonce.chomp @@ -1123,10 +1137,10 @@ class TestGoFZF < TestBase 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| - lines[-2].include?('95/95') && - lines[-3] == ' 11111' && - lines[-7] == ' 55555' && - lines[-8] == '> 66666' + 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 @@ -1134,92 +1148,101 @@ class TestGoFZF < TestBase def test_header tmux.send_keys "seq 100 | #{fzf("--header \"$(head -5 #{FILE})\"")}", :Enter - header = File.readlines(FILE).take(5).map(&:strip) + header = File.readlines(FILE, chomp: true).take(5) tmux.until do |lines| - lines[-2].include?('100/100') && - lines[-7..-3].map(&:strip) == header && - lines[-8] == '> 1' + 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).take(5).map(&:strip) + header = File.readlines(FILE, chomp: true).take(5) tmux.until do |lines| - lines[1].include?('100/100') && - lines[2..6].map(&:strip) == header && - lines[7] == '> 1' + 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).take(5).map(&:strip) + header = File.readlines(FILE, chomp: true).take(5) tmux.until do |lines| - lines[-2].include?('100/100') && - lines[-7..-3].map(&:strip) == header && - lines[0] == '> 1' + 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).take(5).map(&:strip) + header = File.readlines(FILE, chomp: true).take(5) tmux.until do |lines| - lines[-2].include?('90/90') && - lines[-7...-2].map(&:strip) == header && - lines[-17...-7].map(&:strip) == (1..10).map(&:to_s).reverse + 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).take(5).map(&:strip) + header = File.readlines(FILE, chomp: true).take(5) tmux.until do |lines| - lines[1].include?('90/90') && - lines[2...7].map(&:strip) == header && - lines[7...17].map(&:strip) == (1..10).map(&:to_s) + 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).take(5).map(&:strip) + header = File.readlines(FILE, chomp: true).take(5) tmux.until do |lines| - lines[-2].include?('90/90') && - lines[-7...-2].map(&:strip) == header && - lines[-17...-7].map(&:strip) == (1..10).map(&:to_s).reverse + 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| lines[-2].include?('10/10') } + tmux.until { |lines| assert_equal ' 10/10', lines[-2] } tmux.send_keys '123' - tmux.until { |lines| lines[-1] == '> 3' && lines[-2].include?('1/10') } + 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| lines[-1] == '> 311' } + tmux.until { |lines| assert_equal '> 311', lines[-1] } tmux.send_keys 2 - tmux.until { |lines| lines[-1] == '>' } + 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 { |lines| lines[4] == '' && lines[5] == ' y' } + 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| lines[1 + 7] == ' 1000/1000' } + 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 { |lines| lines[4] == '' && lines[5] == ' > y' } + tmux.until do |lines| + assert_equal '', lines[4] + assert_equal ' > y', lines[5] + end tmux.send_keys :Enter end @@ -1239,7 +1262,7 @@ class TestGoFZF < TestBase tmux.prepare tmux.send_keys %(cat #{tempname} | fzf --tabstop=#{ts}), :Enter tmux.until(true) do |lines| - exp.start_with?(lines[-3].to_s.strip.sub(/\.\.$/, '')) + assert_equal exp, lines[-3] end tmux.send_keys :Enter end @@ -1275,16 +1298,16 @@ class TestGoFZF < TestBase def test_invalid_option lines = `#{FZF} --foobar 2>&1` assert_equal 2, $CHILD_STATUS.exitstatus - assert lines.include?('unknown option: --foobar'), lines + assert_includes lines, 'unknown option: --foobar' end def test_filter_exitstatus # filter / streaming filter ['', '--no-sort'].each do |opts| - assert `echo foo | #{FZF} -f foo #{opts}`.include?('foo') + assert_includes `echo foo | #{FZF} -f foo #{opts}`, 'foo' assert_equal 0, $CHILD_STATUS.exitstatus - assert `echo foo | #{FZF} -f bar #{opts}`.empty? + assert_empty `echo foo | #{FZF} -f bar #{opts}` assert_equal 1, $CHILD_STATUS.exitstatus end end @@ -1292,9 +1315,9 @@ class TestGoFZF < TestBase 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| lines[-2] =~ %r{ [10]/100} } + tmux.until { |lines| assert_match %r{ [10]/100}, lines[-2] } tmux.send_keys :Enter - tmux.until { |lines| lines.last.include?("--#{status}--") } + tmux.until { |lines| assert_equal "--#{status}--", lines.last } end end @@ -1310,9 +1333,9 @@ class TestGoFZF < TestBase end def test_or_operator - assert_equal %w[1 5 10], `seq 10 | #{FZF} -f "1 | 5"`.lines.map(&:chomp) + 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.map(&:chomp) + `seq 10 | #{FZF} -f '1 | !1'`.lines(chomp: true) end def test_hscroll_off @@ -1320,56 +1343,56 @@ class TestGoFZF < TestBase [0, 3, 6].each do |off| tmux.prepare tmux.send_keys "#{FZF} --hscroll-off=#{off} -q 0 < #{tempname}", :Enter - tmux.until { |lines| lines[-3].end_with?((0..off).to_a.join + '..') } + tmux.until { |lines| assert lines[-3]&.end_with?((0..off).to_a.join + '..') } tmux.send_keys '9' - tmux.until { |lines| lines[-3].end_with?('789') } + 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| lines[-2] == ' 1000/1000' } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys 11 - tmux.until { |lines| lines[-2] == ' 19/1000' } + tmux.until { |lines| assert_equal ' 19/1000', lines[-2] } tmux.send_keys 'C-a', "'" - tmux.until { |lines| lines[-2] == ' 28/1000' } + 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| lines[-2] == ' 1000/1000' } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys 'C-j' - tmux.until { |lines| lines[-7] == '5 5' } - tmux.until { |lines| lines[-8] == ' 6' } + tmux.until { |lines| assert_equal '5 5', lines[-7] } + tmux.until { |lines| assert_equal ' 6', lines[-8] } tmux.send_keys '5' - tmux.until { |lines| lines[-7] == '> 5' } + tmux.until { |lines| assert_equal '> 5', lines[-7] } tmux.send_keys :Tab - tmux.until { |lines| lines[-7] == ' >5' } + tmux.until { |lines| assert_equal ' >5', lines[-7] } tmux.send_keys 'C-j' - tmux.until { |lines| lines[-7] == '5>5' } + tmux.until { |lines| assert_equal '5>5', lines[-7] } tmux.send_keys '2' - tmux.until { |lines| lines[-4] == '> 2' } + tmux.until { |lines| assert_equal '> 2', lines[-4] } tmux.send_keys :Tab - tmux.until { |lines| lines[-4] == ' >2' } + tmux.until { |lines| assert_equal ' >2', lines[-4] } tmux.send_keys 'C-j' - tmux.until { |lines| lines[-7] == '5>5' } + 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| lines[-3] == '> 1' } + tmux.until { |lines| assert_equal '> 1', lines[-3] } tmux.send_keys :Tab - tmux.until { |lines| lines[-3] == '>>1' } + tmux.until { |lines| assert_equal '>>1', lines[-3] } tmux.send_keys :Enter - assert_equal %w[5 2 1], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[5 2 1], readonce.lines(chomp: true) end def test_jump_accept tmux.send_keys "seq 1000 | #{fzf("--multi --jump-labels 12345 --bind 'ctrl-j:jump-accept'")}", :Enter - tmux.until { |lines| lines[-2] == ' 1000/1000' } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys 'C-j' - tmux.until { |lines| lines[-7] == '5 5' } + tmux.until { |lines| assert_equal '5 5', lines[-7] } tmux.send_keys '3' assert_equal '3', readonce.chomp end @@ -1377,66 +1400,66 @@ class TestGoFZF < TestBase def test_pointer tmux.send_keys "seq 10 | #{fzf("--pointer '>>'")}", :Enter # Assert that specified pointer is displayed - tmux.until { |lines| lines[-3] == '>> 1' } + 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| lines[-2] == ' 10/10' } + tmux.until { |lines| assert_equal ' 10/10', lines[-2] } tmux.send_keys 'C-j' # Correctly padded jump label should appear - tmux.until { |lines| lines[-7] == '5 5' } - tmux.until { |lines| lines[-8] == ' 6' } + 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| lines[-7] == '>> 5' } + tmux.until { |lines| assert_equal '>> 5', lines[-7] } end def test_marker tmux.send_keys "seq 10 | #{fzf("--multi --marker '>>'")}", :Enter - tmux.until { |lines| lines[-2] == ' 10/10' } + tmux.until { |lines| assert_equal ' 10/10', lines[-2] } tmux.send_keys :BTab # Assert that specified marker is displayed - tmux.until { |lines| lines[-3] == ' >>1' } + 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| lines[1].include?(' {1-1}') } + tmux.until { |lines| assert_includes lines[1], ' {1-1} ' } tmux.send_keys :Up - tmux.until { |lines| lines[1].include?(' {-}') } + tmux.until { |lines| assert_includes lines[1], ' {-} ' } tmux.send_keys '555' - tmux.until { |lines| lines[1].include?(' {555-555}') } + tmux.until { |lines| assert_includes lines[1], ' {555-555} ' } tmux.send_keys '?' - tmux.until { |lines| !lines[1].include?(' {555-555}') } + tmux.until { |lines| refute_includes lines[1], ' {555-555} ' } tmux.send_keys '?' - tmux.until { |lines| lines[1].include?(' {555-555}') } + tmux.until { |lines| assert_includes lines[1], ' {555-555} ' } tmux.send_keys :BSpace - tmux.until { |lines| lines[-2].start_with?(' 28/1000') } + tmux.until { |lines| assert lines[-2]&.start_with?(' 28/1000 ') } tmux.send_keys 'foobar' - tmux.until { |lines| !lines[1].include?('{') } + tmux.until { |lines| refute_includes lines[1], ' {55-55} ' } tmux.send_keys 'C-u' - tmux.until { |lines| lines.match_count == 1000 } - tmux.until { |lines| lines[1].include?(' {1-1}') } + 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| lines[1].include?(' {-1}') } + tmux.until { |lines| assert_includes lines[1], ' {-1} ' } tmux.send_keys :BTab - tmux.until { |lines| lines[1].include?(' {3-1 }') } + tmux.until { |lines| assert_includes lines[1], ' {3-1 } ' } tmux.send_keys :BTab - tmux.until { |lines| lines[1].include?(' {4-1 3}') } + tmux.until { |lines| assert_includes lines[1], ' {4-1 3} ' } tmux.send_keys :BTab - tmux.until { |lines| lines[1].include?(' {5-1 3 4}') } + tmux.until { |lines| assert_includes lines[1], ' {5-1 3 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| lines[-1] == '>' } + tmux.until { |lines| assert_equal '>', lines[-1] } tmux.send_keys '?' - tmux.until { |lines| lines[-2] =~ / {1-1-1-[0-9]+}/ } + tmux.until { |lines| assert_match(/ {1-1-1-[0-9]+}/, lines[-2]) } tmux.send_keys '555' - tmux.until { |lines| lines[-2] =~ / {555-555-1-[0-9]+}/ } + tmux.until { |lines| assert_match(/ {555-555-1-[0-9]+}/, lines[-2]) } tmux.send_keys '?' - tmux.until { |lines| lines[-1] == '> 555' } + tmux.until { |lines| assert_equal '> 555', lines[-1] } end def test_preview_size_0 @@ -1446,132 +1469,148 @@ class TestGoFZF < TestBase nil end tmux.send_keys %(seq 100 | #{FZF} --reverse --preview 'echo {} >> #{tempname}; echo ' --preview-window 0), :Enter - tmux.until { |lines| lines.item_count == 100 && lines[1] == ' 100/100' && lines[2] == '> 1' } - wait { File.exist?(tempname) && File.readlines(tempname).map(&:chomp) == %w[1] } + 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| lines[3] == '> 2' } - wait { File.exist?(tempname) && File.readlines(tempname).map(&:chomp) == %w[1 2] } + 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| lines[4] == '> 3' } - wait { File.exist?(tempname) && File.readlines(tempname).map(&:chomp) == %w[1 2 3] } + 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 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| lines[1].include?('{1/1 /1/1 //0/0}') } + tmux.until { |lines| assert_includes lines[1], ' {1/1 /1/1 //0/0} ' } tmux.send_keys '123' - tmux.until { |lines| lines[1].include?('{////123//}') } + tmux.until { |lines| assert_includes lines[1], ' {////123//} ' } tmux.send_keys 'C-u', '1' - tmux.until { |lines| lines.match_count == 2 } - tmux.until { |lines| lines[1].include?('{1/1 /1/1 /1/0/0}') } + 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| lines[1].include?('{10/10 /1/1 /1/9/0}') } + tmux.until { |lines| assert_includes lines[1], ' {10/10 /1/1 /1/9/0} ' } tmux.send_keys :BTab - tmux.until { |lines| lines[1].include?('{10/10 /1 10/1 10 /1/9/0 9}') } + tmux.until { |lines| assert_includes lines[1], ' {10/10 /1 10/1 10 /1/9/0 9} ' } tmux.send_keys '2' - tmux.until { |lines| lines[1].include?('{//1 10/1 10 /12//0 9}') } + tmux.until { |lines| assert_includes lines[1], ' {//1 10/1 10 /12//0 9} ' } tmux.send_keys '3' - tmux.until { |lines| lines[1].include?('{//1 10/1 10 /123//0 9}') } + 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| lines[1].include?('foo barbar00') } + tmux.until { |lines| assert_includes lines[1], ' foo barbar00 ' } tmux.send_keys :BTab - tmux.until { |lines| lines[1].include?('foo barbar00') } + tmux.until { |lines| assert_includes lines[1], ' foo barbar00 ' } tmux.send_keys :BTab - tmux.until { |lines| lines[1].include?('foo barbar foobarfoo0101') } + 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}'), :Enter - tmux.until { |lines| lines.match_count == 0 } - tmux.until { |lines| !lines[1].include?('foo') } + tmux.until { |lines| assert_equal 0, lines.match_count } + tmux.until { |lines| refute_includes lines[1], ' foo ' } tmux.send_keys 'bar' - tmux.until { |lines| lines[1].include?('foo bar') } + tmux.until { |lines| assert_includes lines[1], ' foo bar ' } tmux.send_keys 'C-u' - tmux.until { |lines| !lines[1].include?('foo') } + tmux.until { |lines| refute_includes lines[1], ' 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| lines.match_count == 0 } - tmux.until { |lines| lines[1].include?('foofoo') } + 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 > #{tempname}", :Enter prompt = '> < 10/10' - tmux.until { |lines| lines[-1] == prompt } + tmux.until { |lines| assert_equal prompt, lines[-1] } tmux.send_keys :Enter - wait { File.exist?(tempname) && File.readlines(tempname).map(&:chomp) == %w[1] } - tmux.until { |lines| lines[-1] == prompt } + 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 def test_info_hidden tmux.send_keys 'seq 10 | fzf --info=hidden', :Enter - tmux.until { |lines| lines[-2] == '> 1' } + tmux.until { |lines| assert_equal '> 1', lines[-2] } end def test_change_top tmux.send_keys %(seq 1000 | #{FZF} --bind change:top), :Enter - tmux.until { |lines| lines.match_count == 1000 } + tmux.until { |lines| assert_equal 1000, lines.match_count } tmux.send_keys :Up - tmux.until { |lines| lines[-4] == '> 2' } + tmux.until { |lines| assert_equal '> 2', lines[-4] } tmux.send_keys 1 - tmux.until { |lines| lines[-3] == '> 1' } + tmux.until { |lines| assert_equal '> 1', lines[-3] } tmux.send_keys :Up - tmux.until { |lines| lines[-4] == '> 10' } + tmux.until { |lines| assert_equal '> 10', lines[-4] } tmux.send_keys 1 - tmux.until { |lines| lines[-3] == '> 11' } + tmux.until { |lines| assert_equal '> 11', lines[-3] } tmux.send_keys :Enter end def test_accept_non_empty tmux.send_keys %(seq 1000 | #{fzf('--print-query --bind enter:accept-non-empty')}), :Enter - tmux.until { |lines| lines.match_count == 1000 } + tmux.until { |lines| assert_equal 1000, lines.match_count } tmux.send_keys 'foo' - tmux.until { |lines| lines[-2].include?('0/1000') } + 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| lines[-2].include?('0/1000') } + tmux.until { |lines| assert_equal ' 0/1000', lines[-2] } tmux.send_keys 'C-u' - tmux.until { |lines| lines[-2].include?('1000/1000') } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys '999' - tmux.until { |lines| lines[-2].include?('1/1000') } + tmux.until { |lines| assert_equal ' 1/1000', lines[-2] } tmux.send_keys :Enter - assert_equal %w[999 999], readonce.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[999 999], readonce.lines(chomp: true) 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| lines.match_count == 1000 } + tmux.until { |lines| assert_equal 1000, lines.match_count } tmux.send_keys :Tab - tmux.until { |lines| lines[-2].include?('1000/1000 (1)') } + tmux.until { |lines| assert_equal ' 1000/1000 (1)', lines[-2] } tmux.send_keys 'foo' - tmux.until { |lines| lines[-2].include?('0/1000') } + 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.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[foo 1], readonce.lines(chomp: true) 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| lines[-2] == ' 0/0' } + 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.split($INPUT_RECORD_SEPARATOR) + assert_equal %w[foo], readonce.lines(chomp: true) end def test_preview_update_on_select tmux.send_keys %(seq 10 | fzf -m --preview 'echo {+}' --bind a:toggle-all), :Enter - tmux.until { |lines| lines.item_count == 10 } + tmux.until { |lines| assert_equal 10, lines.item_count } tmux.send_keys 'a' - tmux.until { |lines| lines.any? { |line| line.include?('1 2 3 4 5') } } + tmux.until { |lines| assert(lines.any? { |line| line.include?(' 1 2 3 4 5 ') }) } tmux.send_keys 'a' - tmux.until { |lines| lines.none? { |line| line.include?('1 2 3 4 5') } } + tmux.until { |lines| lines.each { |line| refute_includes line, ' 1 2 3 4 5 ' } } end def test_escaped_meta_characters @@ -1587,99 +1626,105 @@ class TestGoFZF < TestBase 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.map(&:chomp) - assert_equal ['foo bar'], `#{FZF} -f'^foo\\ bar$' < #{tempname}`.lines.map(&:chomp) + 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.map(&:chomp) + `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 { |lines| lines.item_count == 4 && lines.match_count == 3 } - tmux.until { |lines| lines[-3] == '> aaaaa' } - tmux.until { |lines| lines[-4] == ' b' } - tmux.until { |lines| lines[-5] == ' ccc' } + 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(tempname, ["\x1b[31m+\x1b[m\t\x1b[32mgreen"]) tmux.send_keys "#{FZF} --preview 'cat #{tempname}'", :Enter - tmux.until { |lines| lines[1].include?('+ green') } + tmux.until { |lines| assert_includes lines[1], ' + green ' } end def test_phony tmux.send_keys %(seq 1000 | #{FZF} --query 333 --phony --preview 'echo {} {q}'), :Enter - tmux.until { |lines| lines.match_count == 1000 } - tmux.until { |lines| lines[1].include?('1 333') } + 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| lines.match_count == 1000 } - tmux.until { |lines| lines[1].include?('1 333foo') } + tmux.until { |lines| assert_equal 1000, lines.match_count } + tmux.until { |lines| assert_includes lines[1], ' 1 333foo ' } end 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| lines.match_count == 998 } + tmux.until { |lines| assert_equal 998, lines.match_count } tmux.send_keys 'a' - tmux.until { |lines| lines.item_count == 98 && lines.match_count == 98 } + tmux.until do |lines| + assert_equal 98, lines.item_count + assert_equal 98, lines.match_count + end tmux.send_keys 'b' - tmux.until { |lines| lines.item_count == 198 && lines.match_count == 198 } + tmux.until do |lines| + assert_equal 198, lines.item_count + assert_equal 198, lines.match_count + end tmux.send_keys :Tab - tmux.until { |lines| lines[-2].include?('(1/2)') } + tmux.until { |lines| assert_equal ' 198/198 (1/2)', lines[-2] } tmux.send_keys '555' - tmux.until { |lines| lines.item_count == 553 && lines.match_count == 1 } - tmux.until { |lines| !lines[-2].include?('(1/2)') } + tmux.until { |lines| assert_equal ' 1/553', lines[-2] } end def test_reload_even_when_theres_no_match tmux.send_keys %(: | #{FZF} --bind 'space:reload(seq 10)'), :Enter - tmux.until { |lines| lines.item_count == 0 } + tmux.until { |lines| assert_equal 0, lines.item_count } tmux.send_keys :Space - tmux.until { |lines| lines.item_count == 10 } + tmux.until { |lines| assert_equal 10, 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| lines.any? { |line| line.include?('9') } } + tmux.until { |lines| assert_includes lines, ' 9' } tmux.send_keys :Space - tmux.until { |lines| lines.none? { |line| line.include?('9') } } + 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| lines.item_count == 0 } - tmux.until { |lines| lines.last.include?('> foo') } + 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| lines.last.include?('> barfoo') } + tmux.until { |lines| assert_equal '> barfoo', lines.last } tmux.send_keys :Space - tmux.until { |lines| lines.last == '>' } + tmux.until { |lines| assert_equal '>', lines.last } end def test_clear_selection tmux.send_keys %(seq 100 | #{FZF} --multi --bind space:clear-selection), :Enter - tmux.until { |lines| lines.match_count == 100 } + tmux.until { |lines| assert_equal 100, lines.match_count } tmux.send_keys :Tab - tmux.until { |lines| lines[-2].include?('(1)') } + tmux.until { |lines| assert_equal ' 100/100 (1)', lines[-2] } tmux.send_keys 'foo' - tmux.until { |lines| lines.match_count == 0 } - tmux.until { |lines| lines[-2].include?('(1)') } + tmux.until { |lines| assert_equal ' 0/100 (1)', lines[-2] } tmux.send_keys :Space - tmux.until { |lines| lines.match_count == 0 } - tmux.until { |lines| !lines[-2].include?('(1)') } + tmux.until { |lines| assert_equal ' 0/100', 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| lines[-2] == ' 1000/1000' } + tmux.until { |lines| assert_equal ' 1000/1000', lines[-2] } tmux.send_keys '11' - tmux.until { |lines| lines[-1] == '> 11' } + tmux.until { |lines| assert_equal '> 11', lines[-1] } tmux.send_keys :BSpace - tmux.until { |lines| lines[-1] == '> 1' } + tmux.until { |lines| assert_equal '> 1', lines[-1] } tmux.send_keys :BSpace - tmux.until { |lines| lines[-1] == '>' } + tmux.until { |lines| assert_equal '>', lines[-1] } tmux.send_keys :BSpace tmux.prepare end @@ -1692,14 +1737,14 @@ class TestGoFZF < TestBase tmux.send_keys \ %(echo foo bar | #{FZF} --preview '#{tempname} {2} {1}'), :Enter - tmux.until { |lines| lines.any_include?('bar foo') } + 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", :Enter - tmux.until { |lines| lines.any_include?('9999 10000') } + tmux.until { |lines| assert lines.any_include?('9999 10000') } end end @@ -1730,11 +1775,11 @@ module TestShell tmux.prepare tmux.send_keys 'C-t' - tmux.until { |lines| lines.item_count == 100 } + tmux.until { |lines| assert_equal 100, lines.item_count } tmux.send_keys :Tab, :Tab, :Tab - tmux.until { |lines| lines.any_include?(' (3)') } + tmux.until { |lines| assert lines.any_include?(' (3)') } tmux.send_keys :Enter - tmux.until { |lines| lines.any_include?('1 2 3') } + tmux.until { |lines| assert lines.any_include?('1 2 3') } tmux.send_keys 'C-c' end @@ -1744,38 +1789,38 @@ module TestShell tmux.prepare tmux.send_keys 'echo ', 'C-t' - tmux.until { |lines| lines.item_count == 2 } + tmux.until { |lines| assert_equal 2, lines.item_count } tmux.send_keys 'fzf-unicode' - tmux.until { |lines| lines.match_count == 2 } + tmux.until { |lines| assert_equal 2, lines.match_count } tmux.send_keys '1' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Tab - tmux.until { |lines| lines.select_count == 1 } + tmux.until { |lines| assert_equal 1, lines.select_count } tmux.send_keys :BSpace - tmux.until { |lines| lines.match_count == 2 } + tmux.until { |lines| assert_equal 2, lines.match_count } tmux.send_keys '2' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Tab - tmux.until { |lines| lines.select_count == 2 } + tmux.until { |lines| assert_equal 2, lines.select_count } tmux.send_keys :Enter - tmux.until { |lines| lines.join =~ /echo .*fzf-unicode.*1.* .*fzf-unicode.*2/ } + tmux.until { |lines| assert_match(/echo .*fzf-unicode.*1.* .*fzf-unicode.*2/, lines.join) } tmux.send_keys :Enter - tmux.until { |lines| lines[-1] == 'fzf-unicode 테스트1 fzf-unicode 테스트2' } + 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| lines.match_count > 0 } - expected = lines.reverse.find { |l| l.start_with?('>') }[2..-1] + lines = tmux.until { |lines| assert_operator lines.match_count, :>, 0 } + expected = lines.reverse.find { |l| l.start_with?('> ') }[2..-1] tmux.send_keys :Enter tmux.prepare tmux.send_keys :pwd, :Enter - tmux.until { |lines| lines[-1].end_with?(expected) } + tmux.until { |lines| assert lines[-1]&.end_with?(expected) } end def test_alt_c_command @@ -1786,12 +1831,12 @@ module TestShell tmux.prepare tmux.send_keys :Escape, :c - tmux.until { |lines| lines.item_count == 1 } + tmux.until { |lines| assert_equal 1, lines.item_count } tmux.send_keys :Enter tmux.prepare tmux.send_keys :pwd, :Enter - tmux.until { |lines| lines[-1].end_with?('/tmp') } + tmux.until { |lines| assert_equal '/tmp', lines[-1] } end def test_ctrl_r @@ -1809,31 +1854,31 @@ module TestShell tmux.send_keys 'echo 4th', :Enter tmux.prepare tmux.send_keys 'C-r' - tmux.until { |lines| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } tmux.send_keys 'e3d' # Duplicates removed: 3d (1) + 3rd (1) => 2 matches - tmux.until { |lines| lines.match_count == 2 } - tmux.until { |lines| lines[-3].end_with?('echo 3d') } + 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| lines[-3].end_with?('echo 3rd') } + tmux.until { |lines| assert lines[-3]&.end_with?(' echo 3rd') } tmux.send_keys :Enter - tmux.until { |lines| lines[-1] == 'echo 3rd' } + tmux.until { |lines| assert_equal 'echo 3rd', lines[-1] } tmux.send_keys :Enter - tmux.until { |lines| lines[-1] == '3rd' } + tmux.until { |lines| assert_equal '3rd', lines[-1] } end def test_ctrl_r_multiline tmux.send_keys 'echo "foo', :Enter, 'bar"', :Enter - tmux.until { |lines| lines[-2..-1] == %w[foo bar] } + tmux.until { |lines| assert_equal %w[foo bar], lines[-2..-1] } tmux.prepare tmux.send_keys 'C-r' - tmux.until { |lines| lines[-1] == '>' } + tmux.until { |lines| assert_equal '>', lines[-1] } tmux.send_keys 'foo bar' - tmux.until { |lines| lines[-3].end_with?('bar"') } + tmux.until { |lines| assert lines[-3]&.end_with?('bar"') } tmux.send_keys :Enter - tmux.until { |lines| lines[-1].end_with?('bar"') } + tmux.until { |lines| assert lines[-1]&.end_with?('bar"') } tmux.send_keys :Enter - tmux.until { |lines| lines[-2..-1] == %w[foo bar] } + tmux.until { |lines| assert_equal %w[foo bar], lines[-2..-1] } end def test_ctrl_r_abort @@ -1841,11 +1886,11 @@ module TestShell %w[foo ' "].each do |query| tmux.prepare tmux.send_keys :Enter, query - tmux.until { |lines| lines[-1].start_with?(query) } + tmux.until { |lines| assert lines[-1]&.start_with?(query) } tmux.send_keys 'C-r' - tmux.until { |lines| lines[-1] == "> #{query}" } + tmux.until { |lines| assert_equal "> #{query}", lines[-1] } tmux.send_keys 'C-g' - tmux.until { |lines| lines[-1].start_with?(query) } + tmux.until { |lines| assert lines[-1]&.start_with?(query) } end end end @@ -1860,49 +1905,51 @@ module CompletionTest end tmux.prepare tmux.send_keys 'cat /tmp/fzf-test/10**', :Tab - tmux.until { |lines| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } tmux.send_keys ' !d' - tmux.until { |lines| lines.match_count == 2 } + tmux.until { |lines| assert_equal 2, lines.match_count } tmux.send_keys :Tab, :Tab - tmux.until { |lines| lines.select_count == 2 } + tmux.until { |lines| assert_equal 2, lines.select_count } tmux.send_keys :Enter tmux.until(true) do |lines| - lines[-1].include?('/tmp/fzf-test/10') && - lines[-1].include?('/tmp/fzf-test/100') + assert_equal 'cat /tmp/fzf-test/10 /tmp/fzf-test/100', lines[-1] end # ~USERNAME**<TAB> tmux.send_keys 'C-u' tmux.send_keys "cat ~#{ENV['USER']}**", :Tab - tmux.until { |lines| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } tmux.send_keys "'.fzf-home" - tmux.until { |lines| lines.count { |l| l.include?('.fzf-home') } > 1 } + tmux.until { |lines| assert(lines.any? { |l| l.end_with?('/.fzf-home') }) } tmux.send_keys :Enter tmux.until(true) do |lines| - lines[-1] =~ %r{cat .*/\.fzf-home} + assert_match %r{cat .*/\.fzf-home}, lines[-1] end # ~INVALID_USERNAME**<TAB> tmux.send_keys 'C-u' tmux.send_keys 'cat ~such**', :Tab - tmux.until(true) { |lines| lines.any_include?('no~such~user') } + tmux.until(true) { |lines| assert lines.any_include?('no~such~user') } tmux.send_keys :Enter - tmux.until(true) { |lines| lines[-1].end_with?('no~such~user') } + 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| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } tmux.send_keys 'foobar$' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Enter - tmux.until(true) { |lines| lines[-1].end_with?('/tmp/fzf\ test/foobar') } + 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) { |lines| lines.match_count == 100 && lines.any_include?('/tmp/fzf-test/.hidden-') } + 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| @@ -1912,7 +1959,7 @@ module CompletionTest def test_file_completion_root tmux.send_keys 'ls /**', :Tab - tmux.until { |lines| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } tmux.send_keys :Enter end @@ -1923,40 +1970,40 @@ module CompletionTest FileUtils.touch('/tmp/fzf-test/d55/xxx') tmux.prepare tmux.send_keys 'cd /tmp/fzf-test/**', :Tab - tmux.until { |lines| lines.match_count > 0 } + 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 { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Enter - tmux.until(true) { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/' } + tmux.until(true) { |lines| assert_equal 'cd /tmp/fzf-test/d55/', lines[-1] } tmux.send_keys :xx - tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' } + tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55/xx', lines[-1] } # Should not match regular files (bash-only) if self.class == TestBash tmux.send_keys :Tab - tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' } + 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| lines[-1] == 'cd /tmp/fzf-test/d55' } + tmux.until { |lines| assert_equal 'cd /tmp/fzf-test/d55', lines[-1] } tmux.send_keys :Tab - tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/' } + 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| lines[-1].start_with?('[1]') } - pid = lines[-1].split.last + 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| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } tmux.send_keys 'sleep12345' - tmux.until { |lines| lines.any_include?('sleep 12345') } + tmux.until { |lines| assert lines.any_include?('sleep 12345') } tmux.send_keys :Enter - tmux.until(true) { |lines| lines[-1].include?("kill #{pid}") } + tmux.until(true) { |lines| assert_equal "kill #{pid}", lines[-1] } ensure if pid begin @@ -1971,11 +2018,11 @@ module CompletionTest tmux.send_keys '_fzf_compgen_path() { echo "$1"; seq 10; }', :Enter tmux.prepare tmux.send_keys 'ls /tmp/**', :Tab - tmux.until { |lines| lines.match_count == 11 } + tmux.until { |lines| assert_equal 11, lines.match_count } tmux.send_keys :Tab, :Tab, :Tab - tmux.until { |lines| lines.select_count == 3 } + tmux.until { |lines| assert_equal 3, lines.select_count } tmux.send_keys :Enter - tmux.until(true) { |lines| lines[-1] == 'ls /tmp 1 2' } + tmux.until(true) { |lines| assert_equal 'ls /tmp 1 2', lines[-1] } end def test_unset_completion @@ -1984,44 +2031,44 @@ module CompletionTest # Using tmux tmux.send_keys 'unset FZFFOOBR**', :Tab - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Enter - tmux.until { |lines| lines[-1].include?('unset FZFFOOBAR') } + 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| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Enter - tmux.until { |lines| lines[-1].include?('unset FZFFOOBAR') } + tmux.until { |lines| assert_equal 'unset FZFFOOBAR', lines[-1] } end def test_file_completion_unicode FileUtils.mkdir_p('/tmp/fzf-test') - tmux.paste "cd /tmp/fzf-test; echo -n test3 > $'fzf-unicode \\355\\205\\214\\354\\212\\244\\355\\212\\2701'; echo -n test4 > $'fzf-unicode \\355\\205\\214\\354\\212\\244\\355\\212\\2702'" + 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| lines.match_count == 2 } + tmux.until { |lines| assert_equal 2, lines.match_count } tmux.send_keys '1' - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Tab - tmux.until { |lines| lines.select_count == 1 } + tmux.until { |lines| assert_equal 1, lines.select_count } tmux.send_keys :BSpace - tmux.until { |lines| lines.match_count == 2 } + tmux.until { |lines| assert_equal 2, lines.match_count } tmux.send_keys '2' - tmux.until { |lines| lines.select_count == 1 } + tmux.until { |lines| assert_equal 1, lines.select_count } tmux.send_keys :Tab - tmux.until { |lines| lines.select_count == 2 } + tmux.until { |lines| assert_equal 2, lines.select_count } tmux.send_keys :Enter - tmux.until(true) { |lines| lines[-1] =~ /cat .*fzf-unicode.*1.* .*fzf-unicode.*2/ } + tmux.until(true) { |lines| assert_match(/cat .*fzf-unicode.*1.* .*fzf-unicode.*2/, lines[-1]) } tmux.send_keys :Enter - tmux.until { |lines| lines[-1].include?('test3test4') } + tmux.until { |lines| assert_equal %w[test3 test4], lines[-2..-1] } end def test_custom_completion_api @@ -2030,12 +2077,13 @@ module CompletionTest tmux.prepare tmux.send_keys "#{command} b**", :Tab tmux.until do |lines| - lines.item_count == 2 && lines.match_count == 1 && - lines.any_include?("prompt-#{command}") && - lines.any_include?("preview-#{command}-bar") + 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| lines[-1].include?("#{command} #{command}barbar") } + tmux.until { |lines| assert_equal "#{command} #{command}barbar", lines[-1] } tmux.send_keys 'C-u' end ensure @@ -2063,7 +2111,7 @@ class TestBash < TestBase 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| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } tmux.send_keys 'C-c' tmux.prepare @@ -2072,7 +2120,7 @@ class TestBash < TestBase tmux.prepare tmux.send_keys 'fake /tmp/foo**', :Tab - tmux.until { |lines| lines.match_count > 0 } + tmux.until { |lines| assert_operator lines.match_count, :>, 0 } end end @@ -2094,9 +2142,9 @@ class TestZsh < TestBase ['unset', '\unset', "'unset'"].each do |command| tmux.prepare tmux.send_keys "#{command} FZFFOOBR**", :Tab - tmux.until { |lines| lines.match_count == 1 } + tmux.until { |lines| assert_equal 1, lines.match_count } tmux.send_keys :Enter - tmux.until { |lines| lines[-1].include?("#{command} FZFFOOBAR") } + tmux.until { |lines| assert_equal "#{command} FZFFOOBAR", lines[-1] } tmux.send_keys 'C-c' end end @@ -2112,7 +2160,7 @@ class TestFish < TestBase def new_shell tmux.send_keys 'env FZF_TMUX=1 fish', :Enter tmux.send_keys 'function fish_prompt; end; clear', :Enter - tmux.until(&:empty?) + tmux.until { |lines| assert_empty lines } end def set_var(name, val) |