Remove legacy test code

1 files changed, 0 insertions, 850 deletions

diff --git a/test/test_ruby.rb b/test/test_ruby.rb
deleted file mode 100644
index 25f923b1..00000000
--- a/test/test_ruby.rb
+++ /dev/null
@@ -1,850 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require 'rubygems'
-require 'curses'
-require 'timeout'
-require 'stringio'
-require 'minitest/autorun'
-require 'tempfile'
-$LOAD_PATH.unshift File.expand_path('../..', __FILE__)
-ENV['FZF_EXECUTABLE'] = '0'
-load 'fzf'
-
-class MockTTY
-  def initialize
-    @buffer = ''
-    @mutex = Mutex.new
-    @condv = ConditionVariable.new
-  end
-
-  def read_nonblock sz
-    @mutex.synchronize do
-      take sz
-    end
-  end
-
-  def take sz
-    if @buffer.length >= sz
-      ret = @buffer[0, sz]
-      @buffer = @buffer[sz..-1]
-      ret
-    end
-  end
-
-  def getc
-    sleep 0.1
-    while true
-      @mutex.synchronize do
-        if char = take(1)
-          return char
-        else
-          @condv.wait(@mutex)
-        end
-      end
-    end
-  end
-
-  def << str
-    @mutex.synchronize do
-      @buffer << str
-      @condv.broadcast
-    end
-    self
-  end
-end
-
-class TestRubyFZF < Minitest::Test
-  def setup
-    ENV.delete 'FZF_DEFAULT_SORT'
-    ENV.delete 'FZF_DEFAULT_OPTS'
-    ENV.delete 'FZF_DEFAULT_COMMAND'
-  end
-
-  def test_default_options
-    fzf = FZF.new []
-    assert_equal 1000,  fzf.sort
-    assert_equal false, fzf.multi
-    assert_equal true,  fzf.color
-    assert_equal nil,   fzf.rxflag
-    assert_equal true,  fzf.mouse
-    assert_equal nil,   fzf.nth
-    assert_equal nil,   fzf.with_nth
-    assert_equal true,  fzf.color
-    assert_equal false, fzf.black
-    assert_equal true,  fzf.ansi256
-    assert_equal '',    fzf.query
-    assert_equal false, fzf.select1
-    assert_equal false, fzf.exit0
-    assert_equal nil,   fzf.filter
-    assert_equal nil,   fzf.extended
-    assert_equal false, fzf.reverse
-    assert_equal '> ',  fzf.prompt
-    assert_equal false, fzf.print_query
-  end
-
-  def test_environment_variables
-    # Deprecated
-    ENV['FZF_DEFAULT_SORT'] = '20000'
-    fzf = FZF.new []
-    assert_equal 20000, fzf.sort
-    assert_equal nil,   fzf.nth
-
-    ENV['FZF_DEFAULT_OPTS'] =
-      '-x -m -s 10000 -q "  hello  world  " +c +2 --select-1 -0 ' <<
-      '--no-mouse -f "goodbye world" --black --with-nth=3,-3..,2 --nth=3,-1,2 --reverse --print-query'
-    fzf = FZF.new []
-    assert_equal 10000,   fzf.sort
-    assert_equal '  hello  world  ',
-                          fzf.query
-    assert_equal 'goodbye world',
-                          fzf.filter
-    assert_equal :fuzzy,  fzf.extended
-    assert_equal true,    fzf.multi
-    assert_equal false,   fzf.color
-    assert_equal false,   fzf.ansi256
-    assert_equal true,    fzf.black
-    assert_equal false,   fzf.mouse
-    assert_equal true,    fzf.select1
-    assert_equal true,    fzf.exit0
-    assert_equal true,    fzf.reverse
-    assert_equal true,    fzf.print_query
-    assert_equal [2..2, -1..-1, 1..1], fzf.nth
-    assert_equal [2..2, -3..-1, 1..1], fzf.with_nth
-  end
-
-  def test_option_parser
-    # Long opts
-    fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query hello --select-1
-                     --exit-0 --filter=howdy --extended-exact
-                     --no-mouse --no-256 --nth=1 --with-nth=.. --reverse --prompt (hi)
-                     --print-query]
-    assert_equal 2000,    fzf.sort
-    assert_equal true,    fzf.multi
-    assert_equal false,   fzf.color
-    assert_equal false,   fzf.ansi256
-    assert_equal false,   fzf.black
-    assert_equal false,   fzf.mouse
-    assert_equal 0,       fzf.rxflag
-    assert_equal 'hello', fzf.query
-    assert_equal true,    fzf.select1
-    assert_equal true,    fzf.exit0
-    assert_equal 'howdy', fzf.filter
-    assert_equal :exact,  fzf.extended
-    assert_equal [0..0],  fzf.nth
-    assert_equal nil,     fzf.with_nth
-    assert_equal true,    fzf.reverse
-    assert_equal '(hi)',  fzf.prompt
-    assert_equal true,    fzf.print_query
-
-    # Long opts (left-to-right)
-    fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query=hello
-                     --filter a --filter b --no-256 --black --nth -1 --nth -2
-                     --select-1 --exit-0 --no-select-1 --no-exit-0
-                     --no-sort -i --color --no-multi --256
-                     --reverse --no-reverse --prompt (hi) --prompt=(HI)
-                     --print-query --no-print-query]
-    assert_equal nil,     fzf.sort
-    assert_equal false,   fzf.multi
-    assert_equal true,    fzf.color
-    assert_equal true,    fzf.ansi256
-    assert_equal true,    fzf.black
-    assert_equal true,    fzf.mouse
-    assert_equal 1,       fzf.rxflag
-    assert_equal 'b',     fzf.filter
-    assert_equal 'hello', fzf.query
-    assert_equal false,   fzf.select1
-    assert_equal false,   fzf.exit0
-    assert_equal nil,     fzf.extended
-    assert_equal [-2..-2], fzf.nth
-    assert_equal false,   fzf.reverse
-    assert_equal '(HI)',  fzf.prompt
-    assert_equal false,    fzf.print_query
-
-    # Short opts
-    fzf = FZF.new %w[-s2000 +c -m +i -qhello -x -fhowdy +2 -n3 -1 -0]
-    assert_equal 2000,    fzf.sort
-    assert_equal true,    fzf.multi
-    assert_equal false,   fzf.color
-    assert_equal false,   fzf.ansi256
-    assert_equal 0,       fzf.rxflag
-    assert_equal 'hello', fzf.query
-    assert_equal 'howdy', fzf.filter
-    assert_equal :fuzzy,  fzf.extended
-    assert_equal [2..2],  fzf.nth
-    assert_equal true,    fzf.select1
-    assert_equal true,    fzf.exit0
-
-    # Left-to-right
-    fzf = FZF.new %w[-s 2000 +c -m +i -qhello -x -fgoodbye +2 -n3 -n4,5
-                     -s 3000 -c +m -i -q world +x -fworld -2 --black --no-black
-                     -1 -0 +1 +0
-                    ]
-    assert_equal 3000,    fzf.sort
-    assert_equal false,   fzf.multi
-    assert_equal true,    fzf.color
-    assert_equal true,    fzf.ansi256
-    assert_equal false,   fzf.black
-    assert_equal 1,       fzf.rxflag
-    assert_equal 'world', fzf.query
-    assert_equal false,   fzf.select1
-    assert_equal false,   fzf.exit0
-    assert_equal 'world', fzf.filter
-    assert_equal nil,     fzf.extended
-    assert_equal [3..3, 4..4], fzf.nth
-  rescue SystemExit => e
-    assert false, "Exited"
-  end
-
-  def test_invalid_option
-    [
-      %w[--unknown],
-      %w[yo dawg],
-      %w[--nth=0],
-      %w[-n 0],
-      %w[-n 1..2..3],
-      %w[-n 1....],
-      %w[-n ....3],
-      %w[-n 1....3],
-      %w[-n 1..0],
-      %w[--nth ..0],
-    ].each do |argv|
-      assert_raises(SystemExit) do
-        fzf = FZF.new argv
-      end
-    end
-  end
-
-  def test_width
-    fzf = FZF.new []
-    assert_equal 5, fzf.width('abcde')
-    assert_equal 4, fzf.width('한글')
-    assert_equal 5, fzf.width('한글.')
-  end if RUBY_VERSION >= '1.9'
-
-  def test_trim
-    fzf = FZF.new []
-    assert_equal ['사.',     6], fzf.trim('가나다라마바사.', 4, true)
-    assert_equal ['바사.',   5], fzf.trim('가나다라마바사.', 5, true)
-    assert_equal ['바사.',   5], fzf.trim('가나다라마바사.', 6, true)
-    assert_equal ['마바사.', 4], fzf.trim('가나다라마바사.', 7, true)
-    assert_equal ['가나',    6], fzf.trim('가나다라마바사.', 4, false)
-    assert_equal ['가나',    6], fzf.trim('가나다라마바사.', 5, false)
-    assert_equal ['가나a',   6], fzf.trim('가나ab라마바사.', 5, false)
-    assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 6, false)
-    assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 7, false)
-  end if RUBY_VERSION >= '1.9'
-
-  def test_format
-    fzf = FZF.new []
-    assert_equal [['01234..', false]], fzf.format('0123456789', 7, [])
-    assert_equal [['012', false], ['34', true], ['..', false]],
-      fzf.format('0123456789', 7, [[3, 5]])
-    assert_equal [['..56', false], ['789', true]],
-      fzf.format('0123456789', 7, [[7, 10]])
-    assert_equal [['..56', false], ['78', true], ['9', false]],
-      fzf.format('0123456789', 7, [[7, 9]])
-
-    (3..5).each do |i|
-      assert_equal [['..', false], ['567', true], ['89', false]],
-        fzf.format('0123456789', 7, [[i, 8]])
-    end
-
-    assert_equal [['..', false], ['345', true], ['..', false]],
-      fzf.format('0123456789', 7, [[3, 6]])
-    assert_equal [['012', false], ['34', true], ['..', false]],
-      fzf.format('0123456789', 7, [[3, 5]])
-
-    # Multi-region
-    assert_equal [["0", true], ["1", false], ["2", true], ["34..", false]],
-      fzf.format('0123456789', 7, [[0, 1], [2, 3]])
-
-    assert_equal [["..", false], ["5", true], ["6", false], ["78", true], ["9", false]],
-      fzf.format('0123456789', 7, [[3, 6], [7, 9]])
-
-    assert_equal [["..", false], ["3", true], ["4", false], ["5", true], ["..", false]],
-      fzf.format('0123456789', 7, [[3, 4], [5, 6]])
-
-    # Multi-region Overlap
-    assert_equal [["..", false], ["345", true], ["..", false]],
-      fzf.format('0123456789', 7, [[4, 5], [3, 6]])
-  end
-
-  def test_fuzzy_matcher
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      juice
-      juiceful
-      juiceless
-      juicily
-      juiciness
-      juicy]
-    assert matcher.caches.empty?
-    assert_equal(
-      [["juice",     [[0, 1]]],
-       ["juiceful",  [[0, 1]]],
-       ["juiceless", [[0, 1]]],
-       ["juicily",   [[0, 1]]],
-       ["juiciness", [[0, 1]]],
-       ["juicy",     [[0, 1]]]], matcher.match(list, 'j', '', '').sort)
-    assert !matcher.caches.empty?
-    assert_equal [list.object_id], matcher.caches.keys
-    assert_equal 1, matcher.caches[list.object_id].length
-    assert_equal 6, matcher.caches[list.object_id]['j'].length
-
-    assert_equal(
-      [["juicily",   [[0, 5]]],
-       ["juiciness", [[0, 5]]]], matcher.match(list, 'jii', '', '').sort)
-
-    assert_equal(
-      [["juicily",   [[2, 5]]],
-       ["juiciness", [[2, 5]]]], matcher.match(list, 'ii', '', '').sort)
-
-    assert_equal 3, matcher.caches[list.object_id].length
-    assert_equal 2, matcher.caches[list.object_id]['ii'].length
-
-    # TODO : partial_cache
-  end
-
-  def test_fuzzy_matcher_rxflag
-    assert_equal nil, FZF::FuzzyMatcher.new(nil).rxflag
-    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag
-    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag
-
-    assert_equal 1, FZF::FuzzyMatcher.new(nil).rxflag_for('abc')
-    assert_equal 0, FZF::FuzzyMatcher.new(nil).rxflag_for('Abc')
-    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('abc')
-    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('Abc')
-    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('abc')
-    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('Abc')
-  end
-
-  def test_fuzzy_matcher_case_sensitive
-    # Smart-case match (Uppercase found)
-    assert_equal [['Fruit', [[0, 5]]]],
-      FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
-
-    # Smart-case match (Uppercase not-found)
-    assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-      FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'fruit', '', '').sort
-
-    # Case-sensitive match (-i)
-    assert_equal [['Fruit', [[0, 5]]]],
-      FZF::FuzzyMatcher.new(0).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
-
-    # Case-insensitive match (+i)
-    assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-      FZF::FuzzyMatcher.new(Regexp::IGNORECASE).
-      match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
-  end
-
-  def test_extended_fuzzy_matcher_case_sensitive
-    %w['Fruit Fruit$].each do |q|
-      # Smart-case match (Uppercase found)
-      assert_equal [['Fruit', [[0, 5]]]],
-        FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q, '', '').sort
-
-      # Smart-case match (Uppercase not-found)
-      assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-        FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q.downcase, '', '').sort
-
-      # Case-sensitive match (-i)
-      assert_equal [['Fruit', [[0, 5]]]],
-        FZF::ExtendedFuzzyMatcher.new(0).match(%w[Fruit Grapefruit], q, '', '').sort
-
-      # Case-insensitive match (+i)
-      assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-        FZF::ExtendedFuzzyMatcher.new(Regexp::IGNORECASE).
-        match(%w[Fruit Grapefruit], q, '', '').sort
-    end
-  end
-
-  def test_extended_fuzzy_matcher
-    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      juice
-      juiceful
-      juiceless
-      juicily
-      juiciness
-      juicy
-      _juice]
-    match = proc { |q, prefix|
-      matcher.match(list, q, prefix, '').sort.map { |p| [p.first, p.last.sort] }
-    }
-
-    assert matcher.caches.empty?
-    3.times do
-      ['y j', 'j y'].each do |pat|
-        (0..pat.length - 1).each do |prefix_length|
-          prefix = pat[0, prefix_length]
-          assert_equal(
-            [["juicily", [[0, 1], [6, 7]]],
-             ["juicy",   [[0, 1], [4, 5]]]],
-            match.call(pat, prefix))
-        end
-      end
-
-      # $
-      assert_equal [["juiceful",  [[7, 8]]]], match.call('l$', '')
-      assert_equal [["juiceful",  [[7, 8]]],
-                    ["juiceless", [[5, 6]]],
-                    ["juicily",   [[5, 6]]]], match.call('l', '')
-
-      # ^
-      assert_equal list.length,     match.call('j', '').length
-      assert_equal list.length - 1, match.call('^j', '').length
-
-      # ^ + $
-      assert_equal 0, match.call('^juici$', '').length
-      assert_equal 1, match.call('^juice$', '').length
-      assert_equal 0, match.call('^.*$', '').length
-
-      # !
-      assert_equal 0, match.call('!j', '').length
-
-      # ! + ^
-      assert_equal [["_juice", []]], match.call('!^j', '')
-
-      # ! + $
-      assert_equal list.length - 1, match.call('!l$', '').length
-
-      # ! + f
-      assert_equal [["juicy", [[4, 5]]]], match.call('y !l', '')
-
-      # '
-      assert_equal %w[juiceful juiceless juicily],
-        match.call('il', '').map { |e| e.first }
-      assert_equal %w[juicily],
-        match.call("'il", '').map { |e| e.first }
-      assert_equal (list - %w[juicily]).sort,
-        match.call("!'il", '').map { |e| e.first }.sort
-    end
-    assert !matcher.caches.empty?
-  end
-
-  def test_xfuzzy_matcher_prefix_cache
-    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      a.java
-      b.java
-      java.jive
-      c.java$
-      d.java
-    ]
-    2.times do
-      assert_equal 5, matcher.match(list, 'java',   'java',   '').length
-      assert_equal 3, matcher.match(list, 'java$',  'java$',  '').length
-      assert_equal 1, matcher.match(list, 'java$$', 'java$$', '').length
-
-      assert_equal 0, matcher.match(list, '!java',  '!java',  '').length
-      assert_equal 4, matcher.match(list, '!^jav',  '!^jav',  '').length
-      assert_equal 4, matcher.match(list, '!^java', '!^java', '').length
-      assert_equal 2, matcher.match(list, '!^java !b !c', '!^java', '').length
-    end
-  end
-
-  def test_sort_by_rank
-    matcher  = FZF::FuzzyMatcher.new Regexp::IGNORECASE
-    xmatcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      0____1
-      0_____1
-      01
-      ____0_1
-      01_
-      _01_
-      0______1
-      ___01___
-    ]
-    assert_equal(
-      [["01",       [[0, 2]]],
-       ["01_",      [[0, 2]]],
-       ["_01_",     [[1, 3]]],
-       ["___01___", [[3, 5]]],
-       ["____0_1",  [[4, 7]]],
-       ["0____1",   [[0, 6]]],
-       ["0_____1",  [[0, 7]]],
-       ["0______1", [[0, 8]]]],
-      FZF.sort(matcher.match(list, '01', '', '')))
-
-    assert_equal(
-      [["01",       [[0, 1], [1, 2]]],
-       ["01_",      [[0, 1], [1, 2]]],
-       ["_01_",     [[1, 2], [2, 3]]],
-       ["0____1",   [[0, 1], [5, 6]]],
-       ["0_____1",  [[0, 1], [6, 7]]],
-       ["____0_1",  [[4, 5], [6, 7]]],
-       ["0______1", [[0, 1], [7, 8]]],
-       ["___01___", [[3, 4], [4, 5]]]],
-      FZF.sort(xmatcher.match(list, '0 1', '', '')))
-
-    assert_equal(
-      [["_01_",     [[1, 3], [0, 4]], [4, 4, "_01_"]],
-       ["___01___", [[3, 5], [0, 2]], [4, 8, "___01___"]],
-       ["____0_1",  [[4, 7], [0, 2]], [5, 7, "____0_1"]],
-       ["0____1",   [[0, 6], [1, 3]], [6, 6, "0____1"]],
-       ["0_____1",  [[0, 7], [1, 3]], [7, 7, "0_____1"]],
-       ["0______1", [[0, 8], [1, 3]], [8, 8, "0______1"]]],
-      FZF.sort(xmatcher.match(list, '01 __', '', '')).map { |tuple|
-        tuple << FZF.rank(tuple)
-      }
-    )
-  end
-
-  def test_extended_exact_mode
-    exact = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :exact
-    fuzzy = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy
-    list = %w[
-      extended-exact-mode-not-fuzzy
-      extended'-fuzzy-mode
-    ]
-    assert_equal 2, fuzzy.match(list, 'extended', '', '').length
-    assert_equal 2, fuzzy.match(list, 'mode extended', '', '').length
-    assert_equal 2, fuzzy.match(list, 'xtndd', '', '').length
-    assert_equal 2, fuzzy.match(list, "'-fuzzy", '', '').length
-
-    assert_equal 2, exact.match(list, 'extended', '', '').length
-    assert_equal 2, exact.match(list, 'mode extended', '', '').length
-    assert_equal 0, exact.match(list, 'xtndd', '', '').length
-    assert_equal 1, exact.match(list, "'-fuzzy", '', '').length
-    assert_equal 2, exact.match(list, "-fuzzy", '', '').length
-  end
-
-  # ^$ -> matches empty item
-  def test_format_empty_item
-    fzf = FZF.new []
-    item = ['', [[0, 0]]]
-    line, offsets = item
-    tokens        = fzf.format line, 80, offsets
-    assert_equal [], tokens
-  end
-
-  def test_mouse_event
-    interval = FZF::MouseEvent::DOUBLE_CLICK_INTERVAL
-    me = FZF::MouseEvent.new nil
-    me.v = 10
-    assert_equal false, me.double?(10)
-    assert_equal false, me.double?(20)
-    me.v = 20
-    assert_equal false, me.double?(10)
-    assert_equal false, me.double?(20)
-    me.v = 20
-    assert_equal false, me.double?(10)
-    assert_equal true,  me.double?(20)
-    sleep interval
-    assert_equal false,  me.double?(20)
-  end
-
-  def test_nth_match
-    list = [
-      ' first  second  third',
-      'fourth	 fifth   sixth',
-    ]
-
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
-    assert_equal list, matcher.match(list, 'f', '', '').map(&:first)
-    assert_equal [
-      [list[0], [[2,  5]]],
-      [list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
-
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1]
-    assert_equal [[list[1], [[8, 9]]]], matcher.match(list, 'f', '', '')
-    assert_equal [[list[0], [[8, 9]]]], matcher.match(list, 's', '', '')
-
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2..2]
-    assert_equal [[list[0], [[19, 20]]]], matcher.match(list, 'r', '', '')
-
-    # Comma-separated
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2..2, 0..0]
-    assert_equal [[list[0], [[19, 20]]], [list[1], [[3, 4]]]], matcher.match(list, 'r', '', '')
-
-    # Ordered
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0, 2..2]
-    assert_equal [[list[0], [[3, 4]]], [list[1], [[3, 4]]]], matcher.match(list, 'r', '', '')
-
-    regex = FZF.build_delim_regex "\t"
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0], regex
-    assert_equal [[list[0], [[3, 10]]]], matcher.match(list, 're', '', '')
-
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1], regex
-    assert_equal [], matcher.match(list, 'r', '', '')
-    assert_equal [[list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
-
-    # Negative indexing
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [-1..-1], regex
-    assert_equal [[list[0], [[3, 6]]]], matcher.match(list, 'rt', '', '')
-    assert_equal [[list[0], [[2, 5]]], [list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
-
-    # Regex delimiter
-    regex = FZF.build_delim_regex "[ \t]+"
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0], regex
-    assert_equal [list[1]], matcher.match(list, 'f', '', '').map(&:first)
-
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1], regex
-    assert_equal [[list[0], [[1, 2]]], [list[1], [[8, 9]]]], matcher.match(list, 'f', '', '')
-  end
-
-  def test_nth_match_range
-    list = [
-      ' first  second  third',
-      'fourth	 fifth   sixth',
-    ]
-
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..2]
-    assert_equal [[list[0], [[8, 20]]]], matcher.match(list, 'sr', '', '')
-    assert_equal [], matcher.match(list, 'fo', '', '')
-
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..-1, 0..0]
-    assert_equal [[list[0], [[8, 20]]]], matcher.match(list, 'sr', '', '')
-    assert_equal [[list[1], [[0, 2]]]], matcher.match(list, 'fo', '', '')
-
-    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [0..0, 1..2]
-    assert_equal [], matcher.match(list, '^t', '', '')
-
-    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [0..1, 2..2]
-    assert_equal [[list[0], [[16, 17]]]], matcher.match(list, '^t', '', '')
-
-    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [1..-1]
-    assert_equal [[list[0], [[8, 9]]]], matcher.match(list, '^s', '', '')
-  end
-
-  def stream_for str, delay = 0
-    StringIO.new(str).tap do |sio|
-      sio.instance_eval do
-        alias org_gets gets
-
-        def gets
-          org_gets.tap { |e| sleep(@delay) unless e.nil? }
-        end
-
-        def reopen _
-        end
-      end
-      sio.instance_variable_set :@delay, delay
-    end
-  end
-
-  def assert_fzf_output opts, given, expected
-    stream = stream_for given
-    output = stream_for ''
-
-    def sorted_lines line
-      line.split($/).sort
-    end
-
-    begin
-      tty = MockTTY.new
-      $stdout = output
-      fzf = FZF.new(opts, stream)
-      fzf.instance_variable_set :@tty, tty
-      thr = block_given? && Thread.new { yield tty }
-      fzf.start
-      thr && thr.join
-    rescue SystemExit => e
-      assert_equal 0, e.status
-      assert_equal sorted_lines(expected), sorted_lines(output.string)
-    ensure
-      $stdout = STDOUT
-    end
-  end
-
-  def test_filter
-    {
-      %w[--filter=ol] => 'World',
-      %w[--filter=ol --print-query] => "ol\nWorld",
-    }.each do |opts, expected|
-      assert_fzf_output opts, "Hello\nWorld", expected
-    end
-  end
-
-  def test_select_1
-    {
-      %w[--query=ol --select-1] => 'World',
-      %w[--query=ol --select-1 --print-query] => "ol\nWorld",
-    }.each do |opts, expected|
-      assert_fzf_output opts, "Hello\nWorld", expected
-    end
-  end
-
-  def test_select_1_without_query
-    assert_fzf_output %w[--select-1], 'Hello World', 'Hello World'
-  end
-
-  def test_select_1_ambiguity
-    begin
-      Timeout::timeout(0.5) do
-        assert_fzf_output %w[--query=o --select-1], "hello\nworld", "should not match"
-      end
-    rescue Timeout::Error
-      Curses.close_screen
-    end
-  end
-
-  def test_exit_0
-    {
-      %w[--query=zz --exit-0] => '',
-      %w[--query=zz --exit-0 --print-query] => 'zz',
-    }.each do |opts, expected|
-      assert_fzf_output opts, "Hello\nWorld", expected
-    end
-  end
-
-  def test_exit_0_without_query
-    assert_fzf_output %w[--exit-0], '', ''
-  end
-
-  def test_with_nth
-    source = "hello world\nbatman"
-    assert_fzf_output %w[-0 -1 --with-nth=2,1 -x -q ^worl],
-      source, 'hello world'
-    assert_fzf_output %w[-0 -1 --with-nth=2,1 -x -q llo$],
-      source, 'hello world'
-    assert_fzf_output %w[-0 -1 --with-nth=.. -x -q llo$],
-      source, ''
-    assert_fzf_output %w[-0 -1 --with-nth=2,2,2,..,1 -x -q worlworlworlhellworlhell],
-      source, 'hello world'
-    assert_fzf_output %w[-0 -1 --with-nth=1,1,-1,1 -x -q batbatbatbat],
-      source, 'batman'
-  end
-
-  def test_with_nth_transform
-    fzf = FZF.new %w[--with-nth 2..,1]
-    assert_equal 'my world hello', fzf.transform('hello my world')
-    assert_equal 'my   world hello', fzf.transform('hello   my   world')
-    assert_equal 'my   world  hello', fzf.transform('hello   my   world  ')
-
-    fzf = FZF.new %w[--with-nth 2,-1,2]
-    assert_equal 'my world my', fzf.transform('hello my world')
-    assert_equal 'world world world', fzf.transform('hello world')
-    assert_equal 'world  world  world', fzf.transform('hello world  ')
-  end
-
-  def test_ranking_overlap_match_regions
-    list = [
-      '1           3   4      2',
-      '1           2   3    4'
-    ]
-    assert_equal [
-      ['1           2   3    4',   [[0, 13], [16, 22]]],
-      ['1           3   4      2', [[0, 24], [12, 17]]],
-    ], FZF.sort(FZF::ExtendedFuzzyMatcher.new(nil).match(list, '12 34', '', ''))
-  end
-
-  def test_constrain
-    fzf = FZF.new []
-
-    # [#****             ]
-    assert_equal [false, 0, 0], fzf.constrain(0, 0, 5, 100)
-
-    # *****[**#**  ...   ] => [**#*******  ... ]
-    assert_equal [true, 0, 2], fzf.constrain(5, 7, 10, 100)
-
-    # [**********]**#** => ***[*********#]**
-    assert_equal [true, 3, 12], fzf.constrain(0, 12, 15, 10)
-
-    # *****[**#**  ] => ***[**#****]
-    assert_equal [true, 3, 5], fzf.constrain(5, 7, 10, 7)
-
-    # *****[**#** ] => ****[**#***]
-    assert_equal [true, 4, 6], fzf.constrain(5, 7, 10, 6)
-
-    # *****  [#] => ****[#]
-    assert_equal [true, 4, 4], fzf.constrain(10, 10, 5, 1)
-
-    # [ ] #**** => [#]****
-    assert_equal [true, 0, 0], fzf.constrain(-5, 0, 5, 1)
-
-    # [ ] **#** => **[#]**
-    assert_equal [true, 2, 2], fzf.constrain(-5, 2, 5, 1)
-
-    # [*****  #] => [****#   ]
-    assert_equal [true, 0, 4], fzf.constrain(0, 7, 5, 10)
-
-    # **[*****  #] => [******# ]
-    assert_equal [true, 0, 6], fzf.constrain(2, 10, 7, 10)
-  end
-
-  def test_invalid_utf8
-    tmp = Tempfile.new('fzf')
-    tmp << 'hello ' << [0xff].pack('C*') << ' world' << $/ << [0xff].pack('C*')
-    tmp.close
-    begin
-      Timeout::timeout(0.5) do
-        FZF.new(%w[-n..,1,2.. -q^ -x], File.open(tmp.path)).start
-      end
-    rescue Timeout::Error
-      Curses.close_screen
-    end
-  ensure
-    tmp.unlink
-  end
-
-  def test_with_nth_mock_tty
-    # Manual selection with input
-    assert_fzf_output ["--with-nth=2,1"], "hello world", "hello world" do |tty|
-      tty << "world"
-      tty << "hell"
-      tty << "\r"
-    end
-
-    # Manual selection without input
-    assert_fzf_output ["--with-nth=2,1"], "hello world", "hello world" do |tty|
-      tty << "\r"
-    end
-
-    # Manual selection with input and --multi
-    lines = "hello world\ngoodbye world"
-    assert_fzf_output %w[-m --with-nth=2,1], lines, lines do |tty|
-      tty << "o"
-      tty << "\e[Z\e[Z"
-      tty << "\r"
-    end
-
-    # Manual selection without input and --multi
-    assert_fzf_output %w[-m --with-nth=2,1], lines, lines do |tty|
-      tty << "\e[Z\e[Z"
-      tty << "\r"
-    end
-
-    # ALT-D
-    assert_fzf_output %w[--print-query], "", "hello  baby = world" do |tty|
-      tty << "hello world baby"
-      tty << alt(:b) << alt(:b) << alt(:d)
-      tty << ctrl(:e) << " = " << ctrl(:y)
-      tty << "\r"
-    end
-
-    # ALT-BACKSPACE
-    assert_fzf_output %w[--print-query], "", "hello baby = world " do |tty|
-      tty << "hello world baby"
-      tty << alt(:b) << alt(127.chr)
-      tty << ctrl(:e) << " = " << ctrl(:y)
-      tty << "\r"
-    end
-
-    # Word-movements
-    assert_fzf_output %w[--print-query], "", "ello!_orld!~ foo=?" do |tty|
-      tty << "hello_world==baby?"
-      tty << alt(:b) << ctrl(:d)
-      tty << alt(:b) << ctrl(:d)
-      tty << alt(:b) << ctrl(:d)
-      tty << alt(:f) << '!'
-      tty << alt(:f) << '!'
-      tty << alt(:d) << '~'
-      tty << " foo=bar foo=bar"
-      tty << ctrl(:w)
-      tty << alt(127.chr)
-      tty << "\r"
-    end
-  end
-
-  def alt chr
-    "\e#{chr}"
-  end
-
-  def ctrl char
-    char.to_s.ord - 'a'.ord + 1
-  end
-end
-