highline 2.0.0.pre.develop.9 → 2.0.0.pre.develop.11

data/test/acceptance/acceptance_test.rb

@@ -1,69 +0,0 @@
-# coding: utf-8
-
-require 'highline/import'
-
-class HighLine::AcceptanceTest
-  @@answers ||= {}
-
-  def self.check(&block)
-    caller_file = File.basename(caller[0].split(":")[-3])
-
-    test = new
-    yield test
-    test.caller_file = caller_file
-    test.check
-  end
-
-  def self.answers
-    @@answers
-  end
-
-  def self.answers_for_report
-    answers.map do |file, answer|
-      "#{file}: #{answer}"
-    end.join("\n")
-  end
-
-  # A test description to be shown to user.
-  # It should express what the user is
-  # expected to check.
-  attr_accessor :desc
-
-  # A test action to be checked by the user
-  attr_accessor :action
-
-  # A text asking the confirmation if
-  # the action worked (y) or not (n).
-  attr_accessor :question
-
-  # Automatically filled attribute pointing
-  # to the file where the current test
-  # source is located. So we could check
-  # at the report what tests passed or failed.
-  attr_accessor :caller_file
-
-  def check
-    # Print a header with the test description
-    puts "====="
-    puts "   #{caller_file}"
-    puts "====="
-    puts
-    puts desc
-
-    # Execute the proc/lambda assigned to action
-    puts "---"
-    puts
-    action.call
-    puts
-    puts "---"
-    puts
-
-    # Gather the user feedback about the test
-    print question
-    answer = STDIN.gets.chomp
-    answer = "y" if answer.empty?
-    @@answers[caller_file] = answer
-
-    puts
-  end
-end

data/test/acceptance/at_color_output_using_erb_templates.rb

@@ -1,17 +0,0 @@
-# coding: utf-8
-
-require_relative 'acceptance_test'
-
-HighLine::AcceptanceTest.check do |t|
-  t.desc =
-    "This step checks if coloring "       \
-    "with erb templates is working ok.\n" \
-    "You should see the word _grass_ "    \
-    "colored in green color"
-
-  t.action = Proc.new do
-    say "The <%= color('grass', :green) %> should be green!"
-  end
-
-  t.question = "Do you see the word 'grass' on green color (y/n)? "
-end

data/test/acceptance/at_echo_false.rb

@@ -1,23 +0,0 @@
-# coding: utf-8
-
-require_relative 'acceptance_test'
-
-HighLine::AcceptanceTest.check do |t|
-  t.desc =
-    "This step checks if the 'echo = false' " \
-    "setting is effective in hiding the user " \
-    "typed characters.\n" \
-    "This functionality is useful when asking " \
-    "for passwords.\n" \
-    "When typing the characters you should not " \
-    "see any of them on the screen."
-
-  t.action = Proc.new do
-    answer = ask "Enter some characters and press <enter>: " do |q|
-      q.echo = false
-    end
-    puts "You've entered -> #{answer} <-"
-  end
-
-  t.question = "Were the characters adequately hidden when you typed them (y/n)? "
-end

data/test/acceptance/at_readline.rb

@@ -1,37 +0,0 @@
-# coding: utf-8
-
-require_relative 'acceptance_test'
-
-HighLine::AcceptanceTest.check do |t|
-  t.desc =
-    "This step checks if the readline autocomplete " \
-    "feature is working. \n" \
-    "The test has 5 options you can choose from: " \
-    "save, sample, exec, exit and load.\n" \
-    "If you type the first character of one of them and then press \n" \
-    "the <TAB> key you should see the options available for autocomplete.\n\n" \
-    "For example, if I type 's' and then I press <TAB> I should see a list\n" \
-    "with 'save' and 'sample' as possible options for autocomplete.\n\n" \
-    "Although, if I type 'l' and then press the <TAB> key it should be \n" \
-    "readly autcompleted as 'load', because 'load' is the only option\n" \
-    "that begins with the 'l' letter in this particular case.\n\n" \
-    "If I don't type any character but press <TAB> two times, I should\n" \
-    "be able to see ALL available options.\n\n" \
-    "Please, play with Readline autocomplete for a while, pressing <ENTER>\n" \
-    "to see that it really gets the selected answer.\n" \
-    "When ready, just type 'exit' and the loop will finish.\n\n" \
-    "Don't forget to answer 'y' (yes) or 'n' (no) to the question at the end."
-
-  t.action = Proc.new do
-    loop do
-      cmd =
-      ask "Enter command:  ", %w{ save sample exec exit load } do |q|
-        q.readline = true
-      end
-      say("Executing \"#{cmd}\"...")
-      break if cmd == "exit"
-    end
-  end
-
-  t.question = "Did the Readline autocomplete work fine (y/n)? "
-end

data/test/io_console_compatible.rb

@@ -1,37 +0,0 @@
-# coding: utf-8
-
-require 'stringio'
-require 'tempfile'
-
-#
-# On tests, we try to simulate input output with
-# StringIO, Tempfile and File objects.
-#
-# For this to be accomplished, we have to do some
-# tweaking so that they respond adequately to the
-# called methods during tests.
-#
-
-module IOConsoleCompatible
-  def getch
-    getc
-  end
-
-  attr_accessor :echo
-
-  def winsize
-    [24, 80]
-  end
-end
-
-class Tempfile
-  include IOConsoleCompatible
-end
-
-class File
-  include IOConsoleCompatible
-end
-
-class StringIO
-  include IOConsoleCompatible
-end

data/test/string_methods.rb

@@ -1,35 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-# string_methods.rb
-#
-#  Created by Richard LeBer 2011-06-27
-#
-#  This is Free Software.  See LICENSE and COPYING for details.
-#
-#  String class convenience methods
-
-module StringMethods  
-  def test_color
-    assert_equal("\e[34mstring\e[0m", @string.color(:blue))
-    assert_equal("\e[1m\e[47mstring\e[0m", @string.color(:bold,:on_white))
-    assert_equal("\e[45mstring\e[0m", @string.on(:magenta))
-    assert_equal("\e[36mstring\e[0m", @string.cyan)
-    assert_equal("\e[41m\e[5mstring\e[0m\e[0m", @string.blink.on_red)
-    assert_equal("\e[38;5;137mstring\e[0m", @string.color(:rgb_906030))
-    assert_equal("\e[38;5;101mstring\e[0m", @string.rgb('606030'))
-    assert_equal("\e[38;5;107mstring\e[0m", @string.rgb('60','90','30'))
-    assert_equal("\e[38;5;107mstring\e[0m", @string.rgb(96,144,48))
-    assert_equal("\e[38;5;173mstring\e[0m", @string.rgb_c06030)
-    assert_equal("\e[48;5;137mstring\e[0m", @string.color(:on_rgb_906030))
-    assert_equal("\e[48;5;101mstring\e[0m", @string.on_rgb('606030'))
-    assert_equal("\e[48;5;107mstring\e[0m", @string.on_rgb('60','90','30'))
-    assert_equal("\e[48;5;107mstring\e[0m", @string.on_rgb(96,144,48))
-    assert_equal("\e[48;5;173mstring\e[0m", @string.on_rgb_c06030)
-  end
-  
-  def test_uncolor
-    colored_string = HighLine::String("\e[38;5;137mstring\e[0m")
-    assert_equal "string", colored_string.uncolor
-  end
-end

data/test/test_answer_converter.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-require "test_helper"
-
-require "highline/question"
-
-class TestAnswerConverter < Minitest::Test
-  def test_integer_convertion
-    question = HighLine::Question.new("What's your age?", Integer)
-    question.answer = "18"
-    answer_converter = HighLine::Question::AnswerConverter.new(question)
-
-    refute_equal "18", answer_converter.convert
-    assert_equal   18, answer_converter.convert
-  end
-
-  def test_float_convertion
-    question = HighLine::Question.new("Write PI", Float)
-    question.answer = "3.14159"
-    answer_converter = HighLine::Question::AnswerConverter.new(question)
-
-    refute_equal "3.14159", answer_converter.convert
-    assert_equal   3.14159, answer_converter.convert
-  end
-end

data/test/test_color_scheme.rb

@@ -1,94 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-# tc_color_scheme.rb
-#
-#  Created by Jeremy Hinegardner on 2007-01-24.  
-#  Copyright 2007 Jeremy Hinegardner. All rights reserved.
-#
-#  This is Free Software.  See LICENSE and COPYING for details.
-
-require "test_helper"
-
-require "highline"
-require "stringio"
-
-class TestColorScheme < Minitest::Test
-  def setup
-    HighLine.reset
-    @input    = StringIO.new
-    @output   = StringIO.new
-    @terminal = HighLine.new(@input, @output)
-  end
-
-  def test_using_color_scheme
-    assert_equal(false,HighLine.using_color_scheme?)
-
-    HighLine.color_scheme = HighLine::ColorScheme.new
-    assert_equal(true,HighLine.using_color_scheme?)
-  end
-
-  def test_scheme
-    HighLine.color_scheme = HighLine::SampleColorScheme.new
-
-    @terminal.say("This should be <%= color('warning yellow', :warning) %>.")
-    assert_equal("This should be \e[1m\e[33mwarning yellow\e[0m.\n",@output.string)
-    @output.rewind
-    
-    @terminal.say("This should be <%= color('warning yellow', 'warning') %>.")
-    assert_equal("This should be \e[1m\e[33mwarning yellow\e[0m.\n",@output.string)
-    @output.rewind
-
-    @terminal.say("This should be <%= color('warning yellow', 'WarNing') %>.")
-    assert_equal("This should be \e[1m\e[33mwarning yellow\e[0m.\n",@output.string)
-    @output.rewind
-    
-    # Check that keys are available, and as expected
-    assert_equal ["critical", "error", "warning", "notice", "info", "debug", "row_even", "row_odd"].sort,
-                 HighLine.color_scheme.keys.sort
-    
-    # Color scheme doesn't care if we use symbols or strings, and is case-insensitive
-    warning1 = HighLine.color_scheme[:warning]
-    warning2 = HighLine.color_scheme["warning"]
-    warning3 = HighLine.color_scheme[:wArning]
-    warning4 = HighLine.color_scheme["warniNg"]
-    assert_instance_of HighLine::Style, warning1
-    assert_instance_of HighLine::Style, warning2
-    assert_instance_of HighLine::Style, warning3
-    assert_instance_of HighLine::Style, warning4
-    assert_equal warning1, warning2
-    assert_equal warning1, warning3
-    assert_equal warning1, warning4
-
-    # Nonexistent keys return nil
-    assert_nil HighLine.color_scheme[:nonexistent]
-    
-    # Same as above, for definitions
-    defn1 = HighLine.color_scheme.definition(:warning)
-    defn2 = HighLine.color_scheme.definition("warning")
-    defn3 = HighLine.color_scheme.definition(:wArning)
-    defn4 = HighLine.color_scheme.definition("warniNg")
-    assert_instance_of Array, defn1
-    assert_instance_of Array, defn2
-    assert_instance_of Array, defn3
-    assert_instance_of Array, defn4
-    assert_equal [:bold, :yellow], defn1
-    assert_equal [:bold, :yellow], defn2
-    assert_equal [:bold, :yellow], defn3
-    assert_equal [:bold, :yellow], defn4
-    assert_nil HighLine.color_scheme.definition(:nonexistent)
-    
-    color_scheme_hash = HighLine.color_scheme.to_hash
-    assert_instance_of Hash, color_scheme_hash
-    assert_equal ["critical", "error", "warning", "notice", "info", "debug", "row_even", "row_odd"].sort,
-                 color_scheme_hash.keys.sort
-    assert_instance_of Array, HighLine.color_scheme.definition(:warning)
-    assert_equal [:bold, :yellow], HighLine.color_scheme.definition(:warning)
-
-    # turn it back off, should raise an exception
-    HighLine.color_scheme = nil
-    assert_raises(NameError) {
-      @terminal.say("This should be <%= color('nothing at all', :error) %>.")
-    }
-  end
-end 

data/test/test_helper.rb

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-# Run code coverage only for mri
-require 'simplecov' if RUBY_ENGINE == 'ruby'
-
-# Compatibility module for StringIO, File
-# and Tempfile. Necessary for some tests.
-require "io_console_compatible"
-
-require 'highline'
-debug_message = "Tests will be run under:\n"
-debug_message << "  - #{HighLine.new.terminal.class}\n"
-debug_message << "  - HighLine::VERSION #{HighLine::VERSION}\n"
-
-if defined? RUBY_DESCRIPTION
-  debug_message << "  - #{RUBY_DESCRIPTION}\n"
-end
-
-puts debug_message
-
-require "minitest/autorun"

data/test/test_highline.rb

@@ -1,1627 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-# tc_highline.rb
-#
-#  Created by James Edward Gray II on 2005-04-26.
-#  Copyright 2005 Gray Productions. All rights reserved.
-#
-#  This is Free Software.  See LICENSE and COPYING for details.
-
-require "test_helper"
-
-require "highline"
-require "stringio"
-require "readline"
-require "tempfile"
-
-=begin
-if HighLine::CHARACTER_MODE == "Win32API"
-  class HighLine
-    # Override Windows' character reading so it's not tied to STDIN.
-    def get_character( input = STDIN )
-      input.getc
-    end
-  end
-end
-=end
-
-class TestHighLine < Minitest::Test
-  def setup
-    HighLine.reset
-    @input    = StringIO.new
-    @output   = StringIO.new
-    @terminal = HighLine.new(@input, @output)  
-  end
-  
-  def test_agree_valid_yes_answers
-    valid_yes_answers = %w{ y yes Y YES }
-
-    valid_yes_answers.each do |user_input|
-      @input << "#{user_input}\n"
-      @input.rewind
-
-      assert_equal true, @terminal.agree("Yes or no?  ")
-      assert_equal "Yes or no?  ", @output.string
-
-      @input.truncate(@input.rewind)
-      @output.truncate(@output.rewind)
-    end
-  end
-
-  def test_agree_valid_no_answers
-    valid_no_answers = %w{ n no N NO }
-
-    valid_no_answers.each do |user_input|
-      @input << "#{user_input}\n"
-      @input.rewind
-
-      assert_equal false, @terminal.agree("Yes or no?  ")
-      assert_equal "Yes or no?  ", @output.string
-
-      @input.truncate(@input.rewind)
-      @output.truncate(@output.rewind)
-    end
-  end
-
-  def test_agree_invalid_answers
-    invalid_answers = [ "ye", "yuk", "nope", "Oh yes", "Oh no", "Hell no!"]
-
-    invalid_answers.each do |user_input|
-      # Each invalid answer, should be followed by a 'y' (as the question is reasked)
-      @input << "#{user_input}\ny\n"
-      @input.rewind
-
-      assert_equal true, @terminal.agree("Yes or no?  ")
-
-      # It reasks the question if the answer is invalid
-      assert_equal "Yes or no?  Please enter \"yes\" or \"no\".\nYes or no?  ", @output.string
-
-      @input.truncate(@input.rewind)
-      @output.truncate(@output.rewind)
-    end
-  end
-
-  def test_agree_with_getc
-    @input.truncate(@input.rewind)
-    @input << "yellow"
-    @input.rewind
-
-    assert_equal(true, @terminal.agree("Yes or no?  ", :getc))
-  end
-  
-  def test_agree_with_block
-    @input << "\n\n"
-    @input.rewind
-
-    assert_equal(true, @terminal.agree("Yes or no?  ") { |q| q.default = "y" })
-    assert_equal(false, @terminal.agree("Yes or no?  ") { |q| q.default = "n" })
-  end
-  
-  def test_ask
-    name = "James Edward Gray II"
-    @input << name << "\n"
-    @input.rewind
-
-    assert_equal(name, @terminal.ask("What is your name?  "))
-    
-    assert_raises(EOFError) { @terminal.ask("Any input left?  ") }
-  end
-  
-  def test_ask_string
-    name = "James Edward Gray II"
-    @input << name << "\n"
-    @input.rewind
-
-    assert_equal(name, @terminal.ask("What is your name?  ", String))
-
-    assert_raises(EOFError) { @terminal.ask("Any input left?  ", String) }
-  end
-
-  def test_ask_string_converting
-    name = "James Edward Gray II"
-    @input << name << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("What is your name?  ", String)
-
-    assert_instance_of HighLine::String, answer
-
-    @input.rewind
-
-    answer = @terminal.ask("What is your name?  ", HighLine::String)
-
-    assert_instance_of HighLine::String, answer
-
-    assert_raises(EOFError) { @terminal.ask("Any input left?  ", HighLine::String) }
-  end
-
-  def test_indent
-    text = "Testing...\n"
-    @terminal.indent_level=1
-    @terminal.say(text)
-    assert_equal(' '*3+text, @output.string)
-
-    @output.truncate(@output.rewind)
-    @terminal.indent_level=3
-    @terminal.say(text)
-    assert_equal(' '*9+text, @output.string)
-
-    @output.truncate(@output.rewind)
-    @terminal.indent_level=0
-    @terminal.indent_size=5
-    @terminal.indent(2, text)
-    assert_equal(' '*10+text, @output.string)
-
-    @output.truncate(@output.rewind)
-    @terminal.indent_level=0
-    @terminal.indent_size=4
-    @terminal.indent {
-      @terminal.say(text)
-    }
-    assert_equal(' '*4+text, @output.string)
-
-    @output.truncate(@output.rewind)
-    @terminal.indent_size=2
-    @terminal.indent(3) { |t|
-      t.say(text)
-    }
-    assert_equal(' '*6+text, @output.string)
-
-    @output.truncate(@output.rewind)
-    @terminal.indent { |t|
-      t.indent {
-        t.indent {
-          t.indent { |tt|
-            tt.say(text)
-          }
-        }
-      }
-    }
-    assert_equal(' '*8+text, @output.string)
-
-    text = "Multi\nLine\nIndentation\n"
-    indent = ' '*4
-    @terminal.indent_level=2
-    @output.truncate(@output.rewind)
-    @terminal.say(text)
-    assert_equal("#{indent}Multi\n#{indent}Line\n#{indent}Indentation\n", @output.string)
-
-    @output.truncate(@output.rewind)
-    @terminal.multi_indent = false
-    @terminal.say(text)
-    assert_equal("#{indent}Multi\nLine\nIndentation\n", @output.string)
-
-    @output.truncate(@output.rewind)
-    @terminal.indent(0, text, true)
-    assert_equal("#{indent}Multi\n#{indent}Line\n#{indent}Indentation\n", @output.string)
-  end
-  
-  def test_newline
-    @terminal.newline
-    @terminal.newline
-    assert_equal("\n\n", @output.string)
-  end
-
-  def test_bug_fixes
-    # auto-complete bug
-    @input << "ruby\nRuby\n"
-    @input.rewind
-
-    languages = [:Perl, :Python, :Ruby]
-    answer = @terminal.ask( "What is your favorite programming language?  ",
-                            languages )
-    assert_equal(languages.last, answer)
-
-    @input.truncate(@input.rewind)
-    @input << "ruby\n"
-    @input.rewind
-
-    answer = @terminal.ask( "What is your favorite programming language?  ",
-                            languages ) do |q|
-      q.case = :capitalize
-    end
-    assert_equal(languages.last, answer)
-    
-    # poor auto-complete error message
-    @input.truncate(@input.rewind)
-    @input << "lisp\nruby\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask( "What is your favorite programming language?  ",
-                            languages ) do |q|
-      q.case = :capitalize
-    end
-    assert_equal(languages.last, answer)
-    assert_equal( "What is your favorite programming language?  " +
-                  "You must choose one of [Perl, Python, Ruby].\n" +
-                  "?  ", @output.string )
-  end
-  
-  def test_case_changes
-    @input << "jeg2\n"
-    @input.rewind
-
-    answer = @terminal.ask("Enter your initials  ") do |q|
-      q.case = :up
-    end
-    assert_equal("JEG2", answer)
-
-    @input.truncate(@input.rewind)
-    @input << "cRaZY\n"
-    @input.rewind
-
-    answer = @terminal.ask("Enter a search string:  ") do |q|
-      q.case = :down
-    end
-    assert_equal("crazy", answer)
-  end
-
-  def test_ask_with_overwrite
-    @input << "Yes, sure!\n"
-    @input.rewind
-
-    answer = @terminal.ask("Do you like Ruby? ") do |q|
-      q.overwrite = true
-      q.echo      = false
-    end
-
-    assert_equal("Yes, sure!", answer)
-    erase_sequence = "\r#{HighLine.Style(:erase_line).code}"
-    assert_equal("Do you like Ruby? #{erase_sequence}", @output.string)
-  end
-
-  def test_ask_with_overwrite_and_character_mode
-    @input << "Y"
-    @input.rewind
-
-    answer = @terminal.ask("Do you like Ruby (Y/N)? ") do |q|
-      q.overwrite = true
-      q.echo      = false
-      q.character = true
-    end
-
-    assert_equal("Y", answer)
-    erase_sequence = "\r#{HighLine.Style(:erase_line).code}"
-    assert_equal("Do you like Ruby (Y/N)? #{erase_sequence}", @output.string)
-  end
-
-  def test_character_echo
-    @input << "password\r"
-    @input.rewind
-
-    answer = @terminal.ask("Please enter your password:  ") do |q|
-      q.echo = "*"
-    end
-    assert_equal("password", answer)
-    assert_equal("Please enter your password:  ********\n", @output.string)
-
-    @input.truncate(@input.rewind)
-    @input << "2"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask( "Select an option (1, 2 or 3):  ",
-                            Integer ) do |q|
-      q.echo      = "*"
-      q.character = true
-    end
-    assert_equal(2, answer)
-    assert_equal("Select an option (1, 2 or 3):  *\n", @output.string)
-  end
-
-  def test_backspace_does_not_enter_prompt
-      @input << "\b\b"
-      @input.rewind
-      answer = @terminal.ask("Please enter your password: ") do |q| 
-        q.echo = "*" 
-      end
-      assert_equal("", answer)
-      assert_equal("Please enter your password: \n", @output.string)
-  end
-
-  def test_after_some_chars_backspace_does_not_enter_prompt_when_ascii
-      @input << "apple\b\b\b\b\b\b\b\b\b\b"
-      @input.rewind
-      answer = @terminal.ask("Please enter your password: ") do |q|
-        q.echo = "*"
-      end
-      assert_equal("", answer)
-      assert_equal("apple".size, @output.string.count("\b"))
-  end
-
-  def test_after_some_chars_backspace_does_not_enter_prompt_when_utf8
-      @input << "maçã\b\b\b\b\b\b\b\b"
-      @input.rewind
-      answer = @terminal.ask("Please enter your password: ") do |q|
-        q.echo = "*"
-      end
-      assert_equal("", answer)
-      assert_equal("maçã".size, @output.string.count("\b"))
-  end
-
-  def test_readline_mode
-    #
-    # Rubinius (and JRuby) seems to be ignoring
-    # Readline input and output assignments. This
-    # ruins testing.
-    #
-    # But it doesn't mean readline is not working
-    # properly on rubinius or jruby.
-    #
-
-    terminal = @terminal.terminal
-
-    if terminal.jruby? or terminal.rubinius? or terminal.windows?
-      skip "We can't test Readline on JRuby, Rubinius and Windows yet"
-    end
-
-    # Creating Tempfiles here because Readline.input
-    #   and Readline.output only accepts a File object
-    #   as argument (not any duck type as StringIO)
-
-    temp_stdin  = Tempfile.new "temp_stdin"
-    temp_stdout = Tempfile.new "temp_stdout"
-
-    Readline.input  = @input  = File.open(temp_stdin.path, 'w+')
-    Readline.output = @output = File.open(temp_stdout.path, 'w+')
-
-    @terminal = HighLine.new(@input, @output)
-
-    @input << "any input\n"
-    @input.rewind
-
-    answer = @terminal.ask("Prompt:  ") do |q|
-      q.readline = true
-    end
-
-    @output.rewind
-    output = @output.read
-
-    assert_equal "any input", answer
-    assert_match "Prompt:  any input\n", output
-
-    @input.close
-    @output.close
-    Readline.input  = STDIN
-    Readline.output = STDOUT
-  end
-
-  def test_readline_mode_with_limit_set
-    temp_stdin  = Tempfile.new "temp_stdin"
-    temp_stdout = Tempfile.new "temp_stdout"
-
-    Readline.input  = @input  = File.open(temp_stdin.path, 'w+')
-    Readline.output = @output = File.open(temp_stdout.path, 'w+')
-
-    @terminal = HighLine.new(@input, @output)
-
-    @input << "any input\n"
-    @input.rewind
-
-    answer = @terminal.ask("Prompt:  ") do |q|
-      q.limit = 50
-      q.readline = true
-    end
-
-    @output.rewind
-    output = @output.read
-
-    assert_equal "any input", answer
-    assert_equal "Prompt:  any input\n", output
-
-    @input.close
-    @output.close
-    Readline.input  = STDIN
-    Readline.output = STDOUT
-  end
-
-  def test_readline_on_non_echo_question_has_prompt
-    @input << "you can't see me"
-    @input.rewind
-    answer = @terminal.ask("Please enter some hidden text: ") do |q|
-      q.readline = true
-      q.echo = "*"
-    end
-    assert_equal("you can't see me", answer)
-    assert_equal("Please enter some hidden text: ****************\n", @output.string)
-  end
-  
-  def test_character_reading
-    # WARNING:  This method does NOT cover Unix and Windows savvy testing!
-    @input << "12345"
-    @input.rewind
-
-    answer = @terminal.ask("Enter a single digit:  ", Integer) do |q|
-      q.character = :getc
-    end
-    assert_equal(1, answer)
-  end
-
-  def test_frozen_statement
-    @terminal.say('This is a frozen statement'.freeze)
-    assert_equal("This is a frozen statement\n", @output.string)
-  end
-
-  def test_color
-    @terminal.say("This should be <%= BLUE %>blue<%= CLEAR %>!")
-    assert_equal("This should be \e[34mblue\e[0m!\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say( "This should be " +
-                   "<%= BOLD + ON_WHITE %>bold on white<%= CLEAR %>!" )
-    assert_equal( "This should be \e[1m\e[47mbold on white\e[0m!\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be \e[36mcyan\e[0m!\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say( "This should be " +
-                   "<%= color('blinking on red', :blink, :on_red) %>!" )
-    assert_equal( "This should be \e[5m\e[41mblinking on red\e[0m!\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This should be <%= NONE %>none<%= CLEAR %>!")
-    assert_equal("This should be \e[38mnone\e[0m!\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This should be <%= RGB_906030 %>rgb_906030<%= CLEAR %>!")
-    assert_equal("This should be \e[38;5;137mrgb_906030\e[0m!\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This should be <%= ON_RGB_C06030 %>on_rgb_c06030<%= CLEAR %>!")
-    assert_equal("This should be \e[48;5;173mon_rgb_c06030\e[0m!\n", @output.string)
-
-    # Relying on const_missing
-    assert_instance_of HighLine::Style, HighLine::ON_RGB_C06031_STYLE
-    assert_instance_of String         , HighLine::ON_RGB_C06032
-    assert_raises(NameError)          { HighLine::ON_RGB_ZZZZZZ }
-
-    # Retrieving color_code from a style
-    assert_equal "\e[41m", @terminal.color_code([HighLine::ON_RED_STYLE])
-
-    @output.truncate(@output.rewind)
-    
-    # Does class method work, too?
-    @terminal.say("This should be <%= HighLine.color('reverse underlined magenta', :reverse, :underline, :magenta) %>!")
-    assert_equal( "This should be \e[7m\e[4m\e[35mreverse underlined magenta\e[0m!\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    # turn off color
-    old_setting = HighLine.use_color?
-    HighLine.use_color = false
-    @terminal.use_color = false
-    @terminal.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be cyan!\n", @output.string)
-    HighLine.use_color = old_setting
-    @terminal.use_color = old_setting
-  end
-
-  def test_color_setting_per_instance
-    require 'highline/import'
-    old_glob_term = $terminal
-    old_setting = HighLine.use_color?
-
-    gterm_input = StringIO.new
-    gterm_output = StringIO.new
-    $terminal = HighLine.new(gterm_input, gterm_output)
-
-    # It can set coloring at HighLine class
-    cli_input = StringIO.new
-    cli_output = StringIO.new
-
-    cli = HighLine.new(cli_input, cli_output)
-
-    # Testing with both use_color setted to true
-    HighLine.use_color = true
-    @terminal.use_color = true
-    cli.use_color = true
-
-    say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be \e[36mcyan\e[0m!\n", gterm_output.string)
-
-    @terminal.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be \e[36mcyan\e[0m!\n", @output.string)
-
-    cli.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be \e[36mcyan\e[0m!\n", cli_output.string)
-
-    gterm_output.truncate(gterm_output.rewind)
-    @output.truncate(@output.rewind)
-    cli_output.truncate(cli_output.rewind)
-
-    # Testing with both use_color setted to false
-    HighLine.use_color = false
-    @terminal.use_color = false
-    cli.use_color = false
-
-    say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be cyan!\n", gterm_output.string)
-
-    @terminal.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be cyan!\n", @output.string)
-
-    cli.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be cyan!\n", cli_output.string)
-
-    gterm_output.truncate(gterm_output.rewind)
-    @output.truncate(@output.rewind)
-    cli_output.truncate(cli_output.rewind)
-
-    # Now check when class and instance doesn't agree about use_color
-
-    # Class false, instance true
-    HighLine.use_color = false
-    @terminal.use_color = false
-    cli.use_color = true
-
-    say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be cyan!\n", gterm_output.string)
-
-    @terminal.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be cyan!\n", @output.string)
-
-    cli.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be \e[36mcyan\e[0m!\n", cli_output.string)
-
-    gterm_output.truncate(gterm_output.rewind)
-    @output.truncate(@output.rewind)
-    cli_output.truncate(cli_output.rewind)
-
-    # Class true, instance false
-    HighLine.use_color = true
-    @terminal.use_color = true
-    cli.use_color = false
-
-    say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be \e[36mcyan\e[0m!\n", gterm_output.string)
-
-    @terminal.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be \e[36mcyan\e[0m!\n", @output.string)
-
-    cli.say("This should be <%= color('cyan', CYAN) %>!")
-    assert_equal("This should be cyan!\n", cli_output.string )
-
-    gterm_output.truncate(gterm_output.rewind)
-    @output.truncate(@output.rewind)
-    cli_output.truncate(cli_output.rewind)
-
-    HighLine.use_color = old_setting
-    @terminal.use_color = old_setting
-    $terminal = old_glob_term
-  end
-
-  def test_reset_use_color
-    HighLine.use_color = false
-    refute HighLine.use_color?
-    HighLine.reset_use_color
-    assert HighLine.use_color?
-  end
-
-  def test_reset_use_color_when_highline_reset
-    HighLine.use_color = false
-    refute HighLine.use_color?
-    HighLine.reset
-    assert HighLine.use_color?
-  end
-
-  def test_uncolor
-    # instance method
-    assert_equal( "This should be reverse underlined magenta!\n",
-                  @terminal.uncolor("This should be \e[7m\e[4m\e[35mreverse underlined magenta\e[0m!\n") 
-                )
-
-    @output.truncate(@output.rewind)
-
-    # class method
-    assert_equal( "This should be reverse underlined magenta!\n",
-                  HighLine.uncolor("This should be \e[7m\e[4m\e[35mreverse underlined magenta\e[0m!\n") 
-                )
-
-    @output.truncate(@output.rewind)
-
-    # RGB color
-    assert_equal( "This should be rgb_906030!\n",
-                  @terminal.uncolor("This should be \e[38;5;137mrgb_906030\e[0m!\n") 
-                )
-  end
-
-  def test_grey_is_the_same_of_gray
-    @terminal.say("<%= GRAY %>")
-    gray_code = @output.string.dup
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= GREY %>")
-    grey_code = @output.string.dup
-    @output.truncate(@output.rewind)
-
-    assert_equal gray_code, grey_code
-  end
-
-  def test_light_is_the_same_as_bright
-    @terminal.say("<%= BRIGHT_BLUE %>")
-    bright_blue_code = @output.string.dup
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= LIGHT_BLUE %>")
-    light_blue_code = @output.string.dup
-    @output.truncate(@output.rewind)
-
-    assert_equal bright_blue_code, light_blue_code
-  end
-                                  
-  def test_confirm
-    @input << "junk.txt\nno\nsave.txt\ny\n"
-    @input.rewind
-
-    answer = @terminal.ask("Enter a filename:  ") do |q|
-      q.confirm = "Are you sure you want to overwrite <%= answer %>?  "
-      q.responses[:ask_on_error] = :question
-    end
-    assert_equal("save.txt", answer)
-    assert_equal( "Enter a filename:  " +
-                  "Are you sure you want to overwrite junk.txt?  " +
-                  "Enter a filename:  " +
-                  "Are you sure you want to overwrite save.txt?  ",
-                  @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "junk.txt\nyes\nsave.txt\nn\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Enter a filename:  ") do |q|
-      q.confirm = "Are you sure you want to overwrite <%= answer %>?  "
-    end
-    assert_equal("junk.txt", answer)
-    assert_equal( "Enter a filename:  " +
-                  "Are you sure you want to overwrite junk.txt?  ",
-                  @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "junk.txt\nyes\nsave.txt\nn\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    scoped_variable = { "junk.txt" => '20mb' }
-    answer = @terminal.ask("Enter a filename:  ") do |q|
-      q.confirm = Proc.new do |answer| 
-        "Are you sure you want to overwrite #{answer} with size " +
-         "of #{scoped_variable[answer]}? "
-      end
-    end
-    assert_equal("junk.txt", answer)
-    assert_equal( "Enter a filename:  " +
-                  "Are you sure you want to overwrite junk.txt " +
-                  "with size of 20mb? ",
-                  @output.string )
-  end
-  
-  def test_generic_confirm_with_true
-    @input << "junk.txt\nno\nsave.txt\ny\n"
-    @input.rewind
-
-    answer = @terminal.ask("Enter a filename:  ") do |q|
-      q.confirm = true
-      q.responses[:ask_on_error] = :question
-    end
-    assert_equal("save.txt", answer)
-    assert_equal( "Enter a filename:  " +
-                  "Are you sure?  " +
-                  "Enter a filename:  " +
-                  "Are you sure?  ",
-                  @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "junk.txt\nyes\nsave.txt\nn\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Enter a filename:  ") do |q|
-      q.confirm = true
-    end
-    assert_equal("junk.txt", answer)
-    assert_equal( "Enter a filename:  " +
-                  "Are you sure?  ",
-                  @output.string )
-  end
-
-  def test_defaults
-    @input << "\nNo Comment\n"
-    @input.rewind
-
-    answer = @terminal.ask("Are you sexually active?  ") do |q|
-      q.validate = /\Ay(?:es)?|no?|no comment\Z/i
-    end
-    assert_equal("No Comment", answer)
-
-    @input.truncate(@input.rewind)
-    @input << "\nYes\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Are you sexually active?  ") do |q|
-      q.default  = "No Comment"
-      q.validate = /\Ay(?:es)?|no?|no comment\Z/i
-    end
-    assert_equal("No Comment", answer)
-    assert_equal( "Are you sexually active?  |No Comment|  ",
-                  @output.string )
-  end
-
-  def test_default_with_String
-    @input << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("Question:  ") do |q|
-      q.default = "string"
-    end
-
-    assert_equal "string", answer
-    assert_equal "Question:  |string|  ", @output.string
-  end
-
-  def test_default_with_Symbol
-    # With a Symbol, it should show up the String version
-    #   at prompt, but return the Symbol as answer
-
-    @input << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("Question:  ") do |q|
-      q.default = :string
-    end
-
-    assert_equal :string, answer
-    assert_equal "Question:  |string|  ", @output.string
-  end
-
-  def test_default_with_non_String_objects
-    # With a non-string object, it should not show
-    #   any 'default' at prompt line. And should
-    #   return the "default" object, without conversion.
-
-    @input << "\n"
-    @input.rewind
-
-    default_non_string_object = Object.new
-
-    answer = @terminal.ask("Question:  ") do |q|
-      q.default = default_non_string_object
-    end
-
-    assert_equal default_non_string_object, answer
-    assert_equal "Question:  ", @output.string
-  end
-
-  def test_string_preservation
-    @input << "Maybe\nYes\n"
-    @input.rewind
-
-    my_string = "Is that your final answer? "
-
-    @terminal.ask(my_string) { |q| q.default = "Possibly" }
-    @terminal.ask(my_string) { |q| q.default = "Maybe" }
-
-    assert_equal("Is that your final answer? ", my_string)
-  end
-
-  def test_empty
-    @input << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("") do |q|
-      q.default  = "yes"
-      q.validate = /\Ay(?:es)?|no?\Z/i
-    end
-    assert_equal("yes", answer)
-  end
-  
-  def test_erb
-    @terminal.say( "The integers from 1 to 10 are:\n" +
-                   "% (1...10).each do |n|\n" +
-                   "\t<%= n %>,\n" +
-                   "% end\n" +
-                   "\tand 10" )
-    assert_equal( "The integers from 1 to 10 are:\n" +
-                  "\t1,\n\t2,\n\t3,\n\t4,\n\t5,\n" +
-                  "\t6,\n\t7,\n\t8,\n\t9,\n\tand 10\n",
-                  @output.string )
-  end
-  
-  def test_files
-    @input << "#{File.basename(__FILE__)[0, 7]}\n"
-    @input.rewind
-    
-    assert_equal "test_hi\n",@input.read
-    @input.rewind
-
-    file = @terminal.ask("Select a file:  ", File) do |q|
-      q.directory = File.expand_path(File.dirname(__FILE__))
-      q.glob      = "*.rb"
-    end
-    assert_instance_of(File, file)
-    assert_equal("#!/usr/bin/env ruby\n", file.gets)
-    file.close
-
-    @input.rewind
-
-    pathname = @terminal.ask("Select a file:  ", Pathname) do |q|
-      q.directory = File.expand_path(File.dirname(__FILE__))
-      q.glob      = "*.rb"
-    end
-    assert_instance_of(Pathname, pathname)
-    assert_equal(File.size(__FILE__), pathname.size)
-  end
-  
-  def test_gather_with_integer
-    @input << "James\nDana\nStorm\nGypsy\n\n"
-    @input.rewind
-
-    answers = @terminal.ask("Enter four names:") do |q|
-      q.gather = 4
-    end
-    assert_equal(%w{James Dana Storm Gypsy}, answers)
-    assert_equal("\n", @input.gets)
-    assert_equal("Enter four names:\n", @output.string)
-  end
-
-  def test_gather_with_an_empty_string
-    @input << "James\nDana\nStorm\nGypsy\n\n"
-    @input.rewind
-
-    answers = @terminal.ask("Enter four names:") do |q|
-      q.gather = ""
-    end
-    assert_equal(%w{James Dana Storm Gypsy}, answers)
-  end
-
-  def test_gather_with_regexp
-    @input << "James\nDana\nStorm\nGypsy\n\n"
-    @input.rewind
-
-    answers = @terminal.ask("Enter four names:") do |q|
-      q.gather = /^\s*$/
-    end
-    assert_equal(%w{James Dana Storm Gypsy}, answers)
-  end
-
-  def test_gather_with_hash
-    @input << "29\n49\n30\n"
-    @input.rewind
-
-    answers = @terminal.ask("<%= key %>:  ", Integer) do |q|
-      q.gather = { "Age" => 0, "Wife's Age" => 0, "Father's Age" => 0}
-    end
-    assert_equal( { "Age" => 29, "Wife's Age" => 30, "Father's Age" => 49},
-                  answers )
-    assert_equal("Age:  Father's Age:  Wife's Age:  ", @output.string)
-  end
-
-  def test_typing_verification
-    @input << "all work and no play makes jack a dull boy\n" * 3
-    @input.rewind
-
-    answer = @terminal.ask("How's work? ") do |q|
-      q.gather = 3
-      q.verify_match = true
-    end
-    assert_equal("all work and no play makes jack a dull boy", answer)
-
-    @input.truncate(@input.rewind)
-    @input << "all play and no work makes jack a mere toy\n"
-    @input << "all work and no play makes jack a dull boy\n" * 5
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("How are things going? ") do |q|
-      q.gather = 3
-      q.verify_match = true
-      q.responses[:mismatch] = 'Typing mismatch!'
-      q.responses[:ask_on_error] = ''
-    end
-    assert_equal("all work and no play makes jack a dull boy", answer)
-
-    # now try using a hash for gather
-
-    @input.truncate(@input.rewind)
-    @input << "Password\nPassword\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("<%= key %>: ") do |q|
-      q.verify_match = true
-      q.gather = {"Enter a password" => '', "Please type it again" => ''}
-    end
-    assert_equal("Password", answer)
-
-    @input.truncate(@input.rewind)
-    @input << "Password\nMistake\nPassword\nPassword\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("<%= key %>: ") do |q|
-      q.verify_match = true
-      q.responses[:mismatch] = 'Typing mismatch!'
-      q.responses[:ask_on_error] = ''
-      q.gather = {"Enter a password" => '', "Please type it again" => ''}
-    end
-
-    assert_equal("Password", answer)
-    assert_equal( "Enter a password: " +
-                  "Please type it again: " +
-                  "Typing mismatch!\n" +
-                  "Enter a password: " +
-                  "Please type it again: ", @output.string )
-  end
-
-  def test_lists
-    digits     = %w{Zero One Two Three Four Five Six Seven Eight Nine}
-    erb_digits = digits.dup
-    erb_digits[erb_digits.index("Five")] = "<%= color('Five', :blue) %%>"
-
-    @terminal.say("<%= list(#{digits.inspect}) %>")
-    assert_equal(digits.map { |d| "#{d}\n" }.join, @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list(#{digits.inspect}, :inline) %>")
-    assert_equal( digits[0..-2].join(", ") + " or #{digits.last}\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list(#{digits.inspect}, :inline, ' and ') %>")
-    assert_equal( digits[0..-2].join(", ") + " and #{digits.last}\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list(#{digits.inspect}, :columns_down, 3) %>")
-    assert_equal( "Zero   Four   Eight\n" +
-                  "One    Five   Nine \n" +
-                  "Two    Six  \n"        +
-                  "Three  Seven\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list(#{erb_digits.inspect}, :columns_down, 3) %>")
-    assert_equal( "Zero   Four   Eight\n" +
-                  "One    \e[34mFive\e[0m   Nine \n" +
-                  "Two    Six  \n" +
-                  "Three  Seven\n",
-                  @output.string )
-
-    colums_of_twenty = ["12345678901234567890"] * 5
-    
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list(#{colums_of_twenty.inspect}, :columns_down) %>")
-    assert_equal( "12345678901234567890  12345678901234567890  " +
-                  "12345678901234567890\n"                       +
-                  "12345678901234567890  12345678901234567890\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list(#{digits.inspect}, :columns_across, 3) %>")
-    assert_equal( "Zero   One    Two  \n" +
-                  "Three  Four   Five \n" + 
-                  "Six    Seven  Eight\n" +
-                  "Nine \n",
-                  @output.string )
-        
-    colums_of_twenty.pop
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list( #{colums_of_twenty.inspect}, :columns_across ) %>")
-    assert_equal( "12345678901234567890  12345678901234567890  " +
-                  "12345678901234567890\n" +
-                  "12345678901234567890\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-    
-    wide = %w[0123456789 a b c d e f g h i j k l m n o p q r s t u v w x y z]
-
-    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_across ) %>")
-    assert_equal( "0123456789  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  " +
-                  "p  q  r  s  t  u  v  w\n"                                  +
-                  "x           y  z\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_across, 10 ) %>")
-    assert_equal( "0123456789  a  b  c  d  e  f  g  h  i\n" +
-                  "j           k  l  m  n  o  p  q  r  s\n" +
-                  "t           u  v  w  x  y  z\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_down ) %>")
-    assert_equal( "0123456789  b  d  f  h  j  l  n  p  r  t  v  x  z\n" +
-                  "a           c  e  g  i  k  m  o  q  s  u  w  y\n",
-                  @output.string )
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_down, 10 ) %>")
-    assert_equal( "0123456789  c  f  i  l  o  r  u  x\n" +
-                  "a           d  g  j  m  p  s  v  y\n" +
-                  "b           e  h  k  n  q  t  w  z\n",
-                  @output.string )
-  end
-  
-  def test_lists_with_zero_items
-    modes = [nil, :rows, :inline, :columns_across, :columns_down]
-    modes.each do |mode|
-      result = @terminal.list([], mode)
-      assert_equal("", result)
-    end
-  end
-
-  def test_lists_with_nil_items
-    modes = [nil]
-    modes.each do |mode|
-      result = @terminal.list([nil], mode)
-      assert_equal("\n", result)
-    end
-  end
-  
-  def test_lists_with_one_item
-    items = ['Zero']
-    modes = { nil            => "Zero\n",
-             :rows           => "Zero\n",
-             :inline         => "Zero",
-             :columns_across => "Zero\n",
-             :columns_down   => "Zero\n" }
-             
-    modes.each do |mode, expected|
-      result = @terminal.list(items, mode)
-      assert_equal(expected, result)
-    end
-  end
-  
-  def test_lists_with_two_items
-    items = ['Zero', 'One']
-    modes = { nil            => "Zero\nOne\n",
-             :rows           => "Zero\nOne\n",
-             :inline         => "Zero or One",
-             :columns_across => "Zero  One \n",
-             :columns_down   => "Zero  One \n" }
-             
-    modes.each do |mode, expected|
-      result = @terminal.list(items, mode)
-      assert_equal(expected, result)
-    end
-  end
-  
-  def test_lists_with_three_items
-    items = ['Zero', 'One', 'Two']
-    modes = { nil            => "Zero\nOne\nTwo\n",
-             :rows           => "Zero\nOne\nTwo\n",
-             :inline         => "Zero, One or Two",
-             :columns_across => "Zero  One   Two \n",
-             :columns_down   => "Zero  One   Two \n" }
-
-    modes.each do |mode, expected|
-      result = @terminal.list(items, mode)
-      assert_equal(expected, result)
-    end
-  end
-  
-  def test_mode
-    assert(%w[HighLine::Terminal::IOConsole HighLine::Terminal::NCurses HighLine::Terminal::UnixStty].include?(@terminal.terminal.character_mode),
-           "#{@terminal.terminal.character_mode} not in list")
-  end
-  
-  class NameClass
-    def self.parse( string )
-      if string =~ /^\s*(\w+),\s*(\w+)\s+(\w+)\s*$/
-        self.new($2, $3, $1)
-      else
-        raise ArgumentError, "Invalid name format."
-      end
-    end
-
-    def initialize(first, middle, last)
-      @first, @middle, @last = first, middle, last
-    end
-    
-    attr_reader :first, :middle, :last
-  end
-  
-  def test_my_class_conversion
-    @input << "Gray, James Edward\n"
-    @input.rewind
-
-    answer = @terminal.ask("Your name?  ", NameClass) do |q|
-      q.validate = lambda do |name|
-        names = name.split(/,\s*/)
-        return false unless names.size == 2
-        return false if names.first =~ /\s/
-        names.last.split.size == 2
-      end
-    end
-    assert_instance_of(NameClass, answer)
-    assert_equal("Gray", answer.last)
-    assert_equal("James", answer.first)
-    assert_equal("Edward", answer.middle)
-  end
-  
-  def test_no_echo
-    @input << "password\r"
-    @input.rewind
-
-    answer = @terminal.ask("Please enter your password:  ") do |q|
-      q.echo = false
-    end
-    assert_equal("password", answer)
-    assert_equal("Please enter your password:  \n", @output.string)
-
-    @input.rewind
-    @output.truncate(@output.rewind)
-    
-    answer = @terminal.ask("Pick a letter or number:  ") do |q|
-      q.character = true
-      q.echo      = false
-    end
-    assert_equal("p", answer)
-    assert_equal("a", @input.getc.chr)
-    assert_equal("Pick a letter or number:  \n", @output.string)
-  end
-  
-  def test_correct_string_encoding_when_echo_false
-    @input << "ação\r" # An UTF-8 portuguese word for 'action'
-    @input.rewind
-
-    answer = @terminal.ask("Please enter your password:  ") do |q|
-      q.echo = false
-    end
-
-    assert_equal "ação", answer
-    assert_equal Encoding::UTF_8, answer.encoding
-  end
-
-  def test_backspace_with_ascii_when_echo_false
-    @input << "password\b\r"
-    @input.rewind
-
-    answer = @terminal.ask("Please enter your password:  ") do |q|
-      q.echo = false
-    end
-
-    refute_equal("password", answer)
-    assert_equal("passwor", answer)
-  end
-
-  def test_backspace_with_utf8_when_echo_false
-    @input << "maçã\b\r"
-    @input.rewind
-
-    answer = @terminal.ask("Please enter your password:  ") do |q|
-      q.echo = false
-    end
-
-    refute_equal("maçã", answer)
-    assert_equal("maç", answer)
-  end
-
-  def test_echoing_with_utf8_when_echo_is_star
-    @input << "maçã\r"
-    @input.rewind
-
-    answer = @terminal.ask("Type:  ") do |q|
-      q.echo = "*"
-    end
-
-    assert_equal("Type:  ****\n", @output.string)
-    assert_equal("maçã", answer)
-  end
-  
-  def test_range_requirements
-    @input << "112\n-541\n28\n"
-    @input.rewind
-
-    answer = @terminal.ask("Tell me your age.", Integer) do |q|
-      q.in = 0..105
-    end
-    assert_equal(28, answer)
-    assert_equal( "Tell me your age.\n" +
-                  "Your answer isn't within the expected range " +
-                  "(included in 0..105).\n" +
-                  "?  " +
-                  "Your answer isn't within the expected range " +
-                  "(included in 0..105).\n" +
-                  "?  ", @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "1\n-541\n28\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Tell me your age.", Integer) do |q|
-      q.above = 3
-    end
-    assert_equal(28, answer)
-    assert_equal( "Tell me your age.\n" +
-                  "Your answer isn't within the expected range " +
-                  "(above 3).\n" +
-                  "?  " +
-                  "Your answer isn't within the expected range " +
-                  "(above 3).\n" +
-                  "?  ", @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "1\n28\n-541\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Lowest numer you can think of?", Integer) do |q|
-      q.below = 0
-    end
-    assert_equal(-541, answer)
-    assert_equal( "Lowest numer you can think of?\n" +
-                  "Your answer isn't within the expected range " +
-                  "(below 0).\n" +
-                  "?  " +
-                  "Your answer isn't within the expected range " +
-                  "(below 0).\n" +
-                  "?  ", @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "-541\n11\n6\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Enter a low even number:  ", Integer) do |q|
-      q.above = 0
-      q.below = 10
-    end
-    assert_equal(6, answer)
-    assert_equal( "Enter a low even number:  " +
-                  "Your answer isn't within the expected range " +
-                  "(above 0 and below 10).\n" +
-                  "?  " +
-                  "Your answer isn't within the expected range " +
-                  "(above 0 and below 10).\n" +
-                  "?  ", @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "1\n-541\n6\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Enter a low even number:  ", Integer) do |q|
-      q.above = 0
-      q.below = 10
-      q.in    = [2, 4, 6, 8]
-    end
-    assert_equal(6, answer)
-    assert_equal( "Enter a low even number:  " +
-                  "Your answer isn't within the expected range " +
-                  "(above 0, below 10, and included in [2, 4, 6, 8]).\n" +
-                  "?  " +
-                  "Your answer isn't within the expected range " +
-                  "(above 0, below 10, and included in [2, 4, 6, 8]).\n" +
-                  "?  ", @output.string )
-  end
-  
-  def test_reask
-    number = 61676
-    @input << "Junk!\n" << number << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("Favorite number?  ", Integer)
-    assert_kind_of(Integer, number)
-    assert_instance_of(Fixnum, number)
-    assert_equal(number, answer)
-    assert_equal( "Favorite number?  " +
-                  "You must enter a valid Integer.\n" +
-                  "?  ", @output.string )
-
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Favorite number?  ", Integer) do |q|
-      q.responses[:ask_on_error] = :question
-      q.responses[:invalid_type] = "Not a valid number!"
-    end
-    assert_kind_of(Integer, number)
-    assert_instance_of(Fixnum, number)
-    assert_equal(number, answer)
-    assert_equal( "Favorite number?  " +
-                  "Not a valid number!\n" +
-                  "Favorite number?  ", @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "gen\ngene\n"
-    @input.rewind
-    @output.truncate(@output.rewind)
-
-    answer = @terminal.ask("Select a mode:  ", [:generate, :gentle])
-    assert_instance_of(Symbol, answer)
-    assert_equal(:generate, answer)
-    assert_equal( "Select a mode:  " +
-                  "Ambiguous choice.  " +
-                  "Please choose one of [generate, gentle].\n" +
-                  "?  ", @output.string )
-  end
-  
-  def test_response_embedding
-    @input << "112\n-541\n28\n"
-    @input.rewind
-
-    answer = @terminal.ask("Tell me your age.", Integer) do |q|
-      q.in = 0..105
-      q.responses[:not_in_range] = "Need a #{q.answer_type}" +
-                                   " #{q.expected_range}."
-    end
-    assert_equal(28, answer)
-    assert_equal( "Tell me your age.\n" +
-                  "Need a Integer included in 0..105.\n" +
-                  "?  " +
-                  "Need a Integer included in 0..105.\n" +
-                  "?  ", @output.string )
-  end
-  
-  def test_say
-    @terminal.say("This will have a newline.")
-    assert_equal("This will have a newline.\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This will also have one newline.\n")
-    assert_equal("This will also have one newline.\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This will not have a newline.  ")
-    assert_equal("This will not have a newline.  ", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This will not have a newline.\t")
-    assert_equal("This will not have a newline.\t", @output.string)
-
-    @output.truncate(@output.rewind)
-    
-    @terminal.say("This will not\n end with a newline. ")
-    assert_equal("This will not\n end with a newline. ", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say("This will \nend with a newline.")
-    assert_equal("This will \nend with a newline.\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    colorized = @terminal.color("This will not have a newline. ", :green)
-    @terminal.say(colorized)
-    assert_equal("\e[32mThis will not have a newline. \e[0m", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    colorized = @terminal.color("This will have a newline.", :green)
-    @terminal.say(colorized)
-    assert_equal("\e[32mThis will have a newline.\e[0m\n", @output.string)
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say(nil)
-    assert_equal("", @output.string)
-  end
-
-  def test_say_handles_non_string_argument
-    integer = 10
-    hash    = { :a => 20 }
-
-    @terminal.say(integer)
-    assert_equal String(integer), @output.string.chomp
-
-    @output.truncate(@output.rewind)
-
-    @terminal.say(hash)
-    assert_equal String(hash), @output.string.chomp
-  end
-
-  def test_terminal_size
-    assert_instance_of(Fixnum, @terminal.terminal.terminal_size[0])
-    assert_instance_of(Fixnum, @terminal.terminal.terminal_size[1])
-  end
-
-  def test_type_conversion
-    number = 61676
-    @input << number << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("Favorite number?  ", Integer)
-    assert_kind_of(Integer, answer)
-    assert_instance_of(Fixnum, answer)
-    assert_equal(number, answer)
-    
-    @input.truncate(@input.rewind)
-    number = 1_000_000_000_000_000_000_000_000_000_000
-    @input << number << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("Favorite number?  ", Integer)
-    assert_kind_of(Integer, answer)
-    assert_instance_of(Bignum, answer)
-    assert_equal(number, answer)
-
-    @input.truncate(@input.rewind)
-    number = 10.5002
-    @input << number << "\n"
-    @input.rewind
-
-    answer = @terminal.ask( "Favorite number?  ",
-                            lambda { |n| n.to_f.abs.round } )
-    assert_kind_of(Integer, answer)
-    assert_instance_of(Fixnum, answer)
-    assert_equal(11, answer)
-
-    @input.truncate(@input.rewind)
-    animal = :dog
-    @input << animal << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("Favorite animal?  ", Symbol)
-    assert_instance_of(Symbol, answer)
-    assert_equal(animal, answer)
-
-    @input.truncate(@input.rewind)
-    @input << "16th June 1976\n"
-    @input.rewind
-
-    answer = @terminal.ask("Enter your birthday.", Date)
-    assert_instance_of(Date, answer)
-    assert_equal(16, answer.day)
-    assert_equal(6, answer.month)
-    assert_equal(1976, answer.year)
-
-    @input.truncate(@input.rewind)
-    pattern = "^yes|no$"
-    @input << pattern << "\n"
-    @input.rewind
-
-    answer = @terminal.ask("Give me a pattern to match with:  ", Regexp)
-    assert_instance_of(Regexp, answer)
-    assert_equal(/#{pattern}/, answer)
-
-    @input.truncate(@input.rewind)
-    @input << "gen\n"
-    @input.rewind
-
-    answer = @terminal.ask("Select a mode:  ", [:generate, :run])
-    assert_instance_of(Symbol, answer)
-    assert_equal(:generate, answer)
-  end
-  
-  def test_validation
-    @input << "system 'rm -rf /'\n105\n0b101_001\n"
-    @input.rewind
-
-    answer = @terminal.ask("Enter a binary number:  ") do |q|
-      q.validate = /\A(?:0b)?[01_]+\Z/
-    end
-    assert_equal("0b101_001", answer)
-    assert_equal( "Enter a binary number:  " +
-                  "Your answer isn't valid " +
-                  "(must match /\\A(?:0b)?[01_]+\\Z/).\n" +
-                  "?  " +
-                  "Your answer isn't valid " +
-                  "(must match /\\A(?:0b)?[01_]+\\Z/).\n" +
-                  "?  ", @output.string )
-
-    @input.truncate(@input.rewind)
-    @input << "Gray II, James Edward\n" +
-              "Gray, Dana Ann Leslie\n" +
-              "Gray, James Edward\n"
-    @input.rewind
-
-    answer = @terminal.ask("Your name?  ") do |q|
-      q.validate = lambda do |name|
-        names = name.split(/,\s*/)
-        return false unless names.size == 2
-        return false if names.first =~ /\s/
-        names.last.split.size == 2
-      end
-    end
-    assert_equal("Gray, James Edward", answer)
-  end
-  
-  def test_whitespace
-    @input << "  A   lot\tof  \t  space\t  \there!   \n"
-    @input.rewind
-    
-    answer = @terminal.ask("Enter a whitespace filled string:  ") do |q|
-      q.whitespace = :chomp
-    end
-    assert_equal("  A   lot\tof  \t  space\t  \there!   ", answer)
-
-    @input.rewind
-
-    answer = @terminal.ask("Enter a whitespace filled string:  ") do |q|
-      q.whitespace = :strip
-    end
-    assert_equal("A   lot\tof  \t  space\t  \there!", answer)
-
-    @input.rewind
-
-    answer = @terminal.ask("Enter a whitespace filled string:  ") do |q|
-      q.whitespace = :collapse
-    end
-    assert_equal(" A lot of space here! ", answer)
-
-    @input.rewind
-
-    answer = @terminal.ask("Enter a whitespace filled string:  ")
-    assert_equal("A   lot\tof  \t  space\t  \there!", answer)
-
-    @input.rewind
-
-    answer = @terminal.ask("Enter a whitespace filled string:  ") do |q|
-      q.whitespace = :strip_and_collapse
-    end
-    assert_equal("A lot of space here!", answer)
-
-    @input.rewind
-
-    answer = @terminal.ask("Enter a whitespace filled string:  ") do |q|
-      q.whitespace = :remove
-    end
-    assert_equal("Alotofspacehere!", answer)
-
-    @input.rewind
-
-    answer = @terminal.ask("Enter a whitespace filled string:  ") do |q|
-      q.whitespace = :none
-    end
-    assert_equal("  A   lot\tof  \t  space\t  \there!   \n", answer)
-
-    @input.rewind
-
-    answer = @terminal.ask("Enter a whitespace filled string:  ") do |q|
-      q.whitespace = nil
-    end
-    assert_equal("  A   lot\tof  \t  space\t  \there!   \n", answer)
-  end
-  
-  def test_track_eof
-    assert_raises(EOFError) { @terminal.ask("Any input left?  ") }
-    
-    # turn EOF tracking
-    old_setting = HighLine.track_eof?
-    HighLine.track_eof = false
-    begin
-      @terminal.ask("And now?  ")  # this will still blow up, nothing available
-    rescue
-      refute_equal(EOFError, $!.class)  # but HighLine's safe guards are off
-    end
-    HighLine.track_eof = old_setting
-  end
-  
-  def test_version
-    refute_nil(HighLine::VERSION)
-    assert_instance_of(String, HighLine::VERSION)
-    assert(HighLine::VERSION.frozen?)
-    assert_match(/\A\d+\.\d+\.\d+(-.*)?/, HighLine::VERSION)
-  end
-end